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:29:26.428] plan(): Setting new future strategy stack:
[01:29:26.430] List of future strategies:
[01:29:26.430] 1. sequential:
[01:29:26.430]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.430]    - tweaked: FALSE
[01:29:26.430]    - call: future::plan("sequential")
[01:29:26.454] plan(): nbrOfWorkers() = 1
> 
> message("*** rng ...")
*** rng ...
> 
> okind <- RNGkind()
> 
> ## A valid regular seed
> f <- Future(42, seed = 42L)
[01:29:26.463] getGlobalsAndPackages() ...
[01:29:26.464] 
[01:29:26.464] - globals: [0] <none>
[01:29:26.464] getGlobalsAndPackages() ... DONE
> print(f)
Future:
Label: '<none>'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: c(10407, -1871565002, 1968597656, -505666782, 1055078269, 658163990, 1090264187)
Resolved: FALSE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'Future', 'environment'
> stopifnot(identical(RNGkind(), okind))
> 
> ## A valid L'Ecuyer-CMRG RNG seed
> seed <- c(407L, 1420090545L, 65713854L, -990249945L,
+           1780737596L, -1213437427L, 1082168682L)
> f <- Future(42, seed = seed)
[01:29:26.466] getGlobalsAndPackages() ...
[01:29:26.466] 
[01:29:26.466] - globals: [0] <none>
[01:29:26.467] getGlobalsAndPackages() ... DONE
> print(f)
Future:
Label: '<none>'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: c(407, 1420090545, 65713854, -990249945, 1780737596, -1213437427, 1082168682)
Resolved: FALSE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'Future', 'environment'
> stopifnot(identical(RNGkind(), okind))
> 
> f <- Future(42, seed = TRUE)
[01:29:26.467] getGlobalsAndPackages() ...
[01:29:26.468] 
[01:29:26.468] - globals: [0] <none>
[01:29:26.468] getGlobalsAndPackages() ... DONE
> print(f)
Future:
Label: '<none>'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: c(10407, 10095349, -709527040, 188514980, 1401516717, -101198042, 707679474)
Resolved: FALSE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'Future', 'environment'
> stopifnot(identical(RNGkind(), okind))
> 
> f <- Future(42, seed = FALSE)
[01:29:26.469] getGlobalsAndPackages() ...
[01:29:26.469] 
[01:29:26.469] - globals: [0] <none>
[01:29:26.469] getGlobalsAndPackages() ... DONE
> print(f)
Future:
Label: '<none>'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: FALSE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'Future', 'environment'
> stopifnot(identical(RNGkind(), okind))
> 
> f <- Future(42, seed = NULL)
[01:29:26.470] getGlobalsAndPackages() ...
[01:29:26.470] 
[01:29:26.471] - globals: [0] <none>
[01:29:26.471] getGlobalsAndPackages() ... DONE
> print(f)
Future:
Label: '<none>'
Expression:
[1] 42
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: R_GlobalEnv
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: <none>
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: FALSE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'Future', 'environment'
> stopifnot(identical(RNGkind(), okind))
> 
> 
> ## See Section 6 on 'Random-number generation' in
> ## vignette("parallel", package = "parallel")
> fsample <- function(x, size = 4L, seed = NULL, what = c("future", "%<-%")) {
+   what <- match.arg(what)
+   
+   ## Must use session-specific '.GlobalEnv' here
+   .GlobalEnv <- globalenv()
+   
+   oseed <- .GlobalEnv$.Random.seed
+   orng <- RNGkind("L'Ecuyer-CMRG")[1L]
+   on.exit(RNGkind(orng))
+ 
+   if (isFALSE(seed) || isNA(seed) || is.null(seed)) {
+     if (what == "future") {
+       fs <- list()
+       for (ii in seq_len(size)) {
+         label <- sprintf("fsample_%d-%d", ii, sample.int(1e6, size=1L))
+         fs[[ii]] <- future({ sample(x, size = 1L) }, seed = seed, label = label)
+ 	print(fs[[ii]])
+       }
+       res <- value(fs)
+     } else {
+       res <- listenv::listenv()
+       for (ii in seq_len(size)) {
+         label <- sprintf("fsample_%d-%d", ii, sample.int(1e6, size=1L))
+         res[[ii]] %<-% { sample(x, size = 1L) } %seed% seed %label% label
+       }
+       res <- as.list(res)
+     }
+   } else {
+     ## Reset state of random seed afterwards?
+     on.exit({
+       if (is.null(oseed)) {
+         rm(list = ".Random.seed", envir = .GlobalEnv, inherits = FALSE)
+       } else {
+         .GlobalEnv$.Random.seed <- oseed
+       }
+     }, add = TRUE)
+ 
+     set.seed(seed)
+ 
+     .seed <- .Random.seed
+   
+     if (what == "future") {
+       fs <- list()
+       for (ii in seq_len(size)) {
+         .seed <- parallel::nextRNGStream(.seed)
+         fs[[ii]] <- future({ sample(x, size = 1L) }, seed = .seed)
+       }
+       res <- value(fs)
+     } else {
+       res <- listenv::listenv()
+       for (ii in seq_len(size)) {
+         .seed <- parallel::nextRNGStream(.seed)
+         res[[ii]] %<-% { sample(x, size = 1L) } %seed% .seed
+       }
+       res <- as.list(res)
+     }
+   }
+   
+   res
+ } # fsample()
> 
> 
> dummy <- sample(0:3, size = 1L)
> seed0 <- .Random.seed
> stopifnot(identical(RNGkind(), okind))
> 
> ## Reference sample with fixed random seed
> plan("sequential")
[01:29:26.480] plan(): Setting new future strategy stack:
[01:29:26.481] List of future strategies:
[01:29:26.481] 1. sequential:
[01:29:26.481]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.481]    - tweaked: FALSE
[01:29:26.481]    - call: plan("sequential")
[01:29:26.510] plan(): nbrOfWorkers() = 1
> y0 <- fsample(0:3, seed = 42L)
[01:29:26.549] getGlobalsAndPackages() ...
[01:29:26.550] Searching for globals...
[01:29:26.563] - globals found: [3] '{', 'sample', 'x'
[01:29:26.563] Searching for globals ... DONE
[01:29:26.563] Resolving globals: FALSE
[01:29:26.565] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:26.565] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:26.566] - globals: [1] 'x'
[01:29:26.566] 
[01:29:26.566] getGlobalsAndPackages() ... DONE
[01:29:26.567] run() for 'Future' ...
[01:29:26.567] - state: 'created'
[01:29:26.568] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:26.568] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:26.568] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:26.569]   - Field: 'label'
[01:29:26.569]   - Field: 'local'
[01:29:26.569]   - Field: 'owner'
[01:29:26.569]   - Field: 'envir'
[01:29:26.569]   - Field: 'packages'
[01:29:26.570]   - Field: 'gc'
[01:29:26.570]   - Field: 'conditions'
[01:29:26.570]   - Field: 'expr'
[01:29:26.570]   - Field: 'uuid'
[01:29:26.571]   - Field: 'seed'
[01:29:26.571]   - Field: 'version'
[01:29:26.571]   - Field: 'result'
[01:29:26.571]   - Field: 'asynchronous'
[01:29:26.571]   - Field: 'calls'
[01:29:26.572]   - Field: 'globals'
[01:29:26.572]   - Field: 'stdout'
[01:29:26.572]   - Field: 'earlySignal'
[01:29:26.572]   - Field: 'lazy'
[01:29:26.572]   - Field: 'state'
[01:29:26.573] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:26.573] - Launch lazy future ...
[01:29:26.574] Packages needed by the future expression (n = 0): <none>
[01:29:26.574] Packages needed by future strategies (n = 0): <none>
[01:29:26.575] {
[01:29:26.575]     {
[01:29:26.575]         {
[01:29:26.575]             ...future.startTime <- base::Sys.time()
[01:29:26.575]             {
[01:29:26.575]                 {
[01:29:26.575]                   {
[01:29:26.575]                     {
[01:29:26.575]                       base::local({
[01:29:26.575]                         has_future <- base::requireNamespace("future", 
[01:29:26.575]                           quietly = TRUE)
[01:29:26.575]                         if (has_future) {
[01:29:26.575]                           ns <- base::getNamespace("future")
[01:29:26.575]                           version <- ns[[".package"]][["version"]]
[01:29:26.575]                           if (is.null(version)) 
[01:29:26.575]                             version <- utils::packageVersion("future")
[01:29:26.575]                         }
[01:29:26.575]                         else {
[01:29:26.575]                           version <- NULL
[01:29:26.575]                         }
[01:29:26.575]                         if (!has_future || version < "1.8.0") {
[01:29:26.575]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:26.575]                             "", base::R.version$version.string), 
[01:29:26.575]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:26.575]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:26.575]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:26.575]                               "release", "version")], collapse = " "), 
[01:29:26.575]                             hostname = base::Sys.info()[["nodename"]])
[01:29:26.575]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:26.575]                             info)
[01:29:26.575]                           info <- base::paste(info, collapse = "; ")
[01:29:26.575]                           if (!has_future) {
[01:29:26.575]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:26.575]                               info)
[01:29:26.575]                           }
[01:29:26.575]                           else {
[01:29:26.575]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:26.575]                               info, version)
[01:29:26.575]                           }
[01:29:26.575]                           base::stop(msg)
[01:29:26.575]                         }
[01:29:26.575]                       })
[01:29:26.575]                     }
[01:29:26.575]                     options(future.plan = NULL)
[01:29:26.575]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.575]                     future::plan("default", .cleanup = FALSE, 
[01:29:26.575]                       .init = FALSE)
[01:29:26.575]                   }
[01:29:26.575]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[01:29:26.575]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[01:29:26.575]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[01:29:26.575]                 }
[01:29:26.575]                 ...future.workdir <- getwd()
[01:29:26.575]             }
[01:29:26.575]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:26.575]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:26.575]         }
[01:29:26.575]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:26.575]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:26.575]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:26.575]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:26.575]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:26.575]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:26.575]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:26.575]             base::names(...future.oldOptions))
[01:29:26.575]     }
[01:29:26.575]     if (FALSE) {
[01:29:26.575]     }
[01:29:26.575]     else {
[01:29:26.575]         if (TRUE) {
[01:29:26.575]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:26.575]                 open = "w")
[01:29:26.575]         }
[01:29:26.575]         else {
[01:29:26.575]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:26.575]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:26.575]         }
[01:29:26.575]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:26.575]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:26.575]             base::sink(type = "output", split = FALSE)
[01:29:26.575]             base::close(...future.stdout)
[01:29:26.575]         }, add = TRUE)
[01:29:26.575]     }
[01:29:26.575]     ...future.frame <- base::sys.nframe()
[01:29:26.575]     ...future.conditions <- base::list()
[01:29:26.575]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:26.575]     if (FALSE) {
[01:29:26.575]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:26.575]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:26.575]     }
[01:29:26.575]     ...future.result <- base::tryCatch({
[01:29:26.575]         base::withCallingHandlers({
[01:29:26.575]             ...future.value <- base::withVisible(base::local({
[01:29:26.575]                 sample(x, size = 1L)
[01:29:26.575]             }))
[01:29:26.575]             future::FutureResult(value = ...future.value$value, 
[01:29:26.575]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.575]                   ...future.rng), globalenv = if (FALSE) 
[01:29:26.575]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:26.575]                     ...future.globalenv.names))
[01:29:26.575]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:26.575]         }, condition = base::local({
[01:29:26.575]             c <- base::c
[01:29:26.575]             inherits <- base::inherits
[01:29:26.575]             invokeRestart <- base::invokeRestart
[01:29:26.575]             length <- base::length
[01:29:26.575]             list <- base::list
[01:29:26.575]             seq.int <- base::seq.int
[01:29:26.575]             signalCondition <- base::signalCondition
[01:29:26.575]             sys.calls <- base::sys.calls
[01:29:26.575]             `[[` <- base::`[[`
[01:29:26.575]             `+` <- base::`+`
[01:29:26.575]             `<<-` <- base::`<<-`
[01:29:26.575]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:26.575]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:26.575]                   3L)]
[01:29:26.575]             }
[01:29:26.575]             function(cond) {
[01:29:26.575]                 is_error <- inherits(cond, "error")
[01:29:26.575]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:26.575]                   NULL)
[01:29:26.575]                 if (is_error) {
[01:29:26.575]                   sessionInformation <- function() {
[01:29:26.575]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:26.575]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:26.575]                       search = base::search(), system = base::Sys.info())
[01:29:26.575]                   }
[01:29:26.575]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.575]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:26.575]                     cond$call), session = sessionInformation(), 
[01:29:26.575]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:26.575]                   signalCondition(cond)
[01:29:26.575]                 }
[01:29:26.575]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:26.575]                 "immediateCondition"))) {
[01:29:26.575]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:26.575]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.575]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:26.575]                   if (TRUE && !signal) {
[01:29:26.575]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.575]                     {
[01:29:26.575]                       inherits <- base::inherits
[01:29:26.575]                       invokeRestart <- base::invokeRestart
[01:29:26.575]                       is.null <- base::is.null
[01:29:26.575]                       muffled <- FALSE
[01:29:26.575]                       if (inherits(cond, "message")) {
[01:29:26.575]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.575]                         if (muffled) 
[01:29:26.575]                           invokeRestart("muffleMessage")
[01:29:26.575]                       }
[01:29:26.575]                       else if (inherits(cond, "warning")) {
[01:29:26.575]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.575]                         if (muffled) 
[01:29:26.575]                           invokeRestart("muffleWarning")
[01:29:26.575]                       }
[01:29:26.575]                       else if (inherits(cond, "condition")) {
[01:29:26.575]                         if (!is.null(pattern)) {
[01:29:26.575]                           computeRestarts <- base::computeRestarts
[01:29:26.575]                           grepl <- base::grepl
[01:29:26.575]                           restarts <- computeRestarts(cond)
[01:29:26.575]                           for (restart in restarts) {
[01:29:26.575]                             name <- restart$name
[01:29:26.575]                             if (is.null(name)) 
[01:29:26.575]                               next
[01:29:26.575]                             if (!grepl(pattern, name)) 
[01:29:26.575]                               next
[01:29:26.575]                             invokeRestart(restart)
[01:29:26.575]                             muffled <- TRUE
[01:29:26.575]                             break
[01:29:26.575]                           }
[01:29:26.575]                         }
[01:29:26.575]                       }
[01:29:26.575]                       invisible(muffled)
[01:29:26.575]                     }
[01:29:26.575]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.575]                   }
[01:29:26.575]                 }
[01:29:26.575]                 else {
[01:29:26.575]                   if (TRUE) {
[01:29:26.575]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.575]                     {
[01:29:26.575]                       inherits <- base::inherits
[01:29:26.575]                       invokeRestart <- base::invokeRestart
[01:29:26.575]                       is.null <- base::is.null
[01:29:26.575]                       muffled <- FALSE
[01:29:26.575]                       if (inherits(cond, "message")) {
[01:29:26.575]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.575]                         if (muffled) 
[01:29:26.575]                           invokeRestart("muffleMessage")
[01:29:26.575]                       }
[01:29:26.575]                       else if (inherits(cond, "warning")) {
[01:29:26.575]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.575]                         if (muffled) 
[01:29:26.575]                           invokeRestart("muffleWarning")
[01:29:26.575]                       }
[01:29:26.575]                       else if (inherits(cond, "condition")) {
[01:29:26.575]                         if (!is.null(pattern)) {
[01:29:26.575]                           computeRestarts <- base::computeRestarts
[01:29:26.575]                           grepl <- base::grepl
[01:29:26.575]                           restarts <- computeRestarts(cond)
[01:29:26.575]                           for (restart in restarts) {
[01:29:26.575]                             name <- restart$name
[01:29:26.575]                             if (is.null(name)) 
[01:29:26.575]                               next
[01:29:26.575]                             if (!grepl(pattern, name)) 
[01:29:26.575]                               next
[01:29:26.575]                             invokeRestart(restart)
[01:29:26.575]                             muffled <- TRUE
[01:29:26.575]                             break
[01:29:26.575]                           }
[01:29:26.575]                         }
[01:29:26.575]                       }
[01:29:26.575]                       invisible(muffled)
[01:29:26.575]                     }
[01:29:26.575]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.575]                   }
[01:29:26.575]                 }
[01:29:26.575]             }
[01:29:26.575]         }))
[01:29:26.575]     }, error = function(ex) {
[01:29:26.575]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:26.575]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.575]                 ...future.rng), started = ...future.startTime, 
[01:29:26.575]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:26.575]             version = "1.8"), class = "FutureResult")
[01:29:26.575]     }, finally = {
[01:29:26.575]         if (!identical(...future.workdir, getwd())) 
[01:29:26.575]             setwd(...future.workdir)
[01:29:26.575]         {
[01:29:26.575]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:26.575]                 ...future.oldOptions$nwarnings <- NULL
[01:29:26.575]             }
[01:29:26.575]             base::options(...future.oldOptions)
[01:29:26.575]             if (.Platform$OS.type == "windows") {
[01:29:26.575]                 old_names <- names(...future.oldEnvVars)
[01:29:26.575]                 envs <- base::Sys.getenv()
[01:29:26.575]                 names <- names(envs)
[01:29:26.575]                 common <- intersect(names, old_names)
[01:29:26.575]                 added <- setdiff(names, old_names)
[01:29:26.575]                 removed <- setdiff(old_names, names)
[01:29:26.575]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:26.575]                   envs[common]]
[01:29:26.575]                 NAMES <- toupper(changed)
[01:29:26.575]                 args <- list()
[01:29:26.575]                 for (kk in seq_along(NAMES)) {
[01:29:26.575]                   name <- changed[[kk]]
[01:29:26.575]                   NAME <- NAMES[[kk]]
[01:29:26.575]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.575]                     next
[01:29:26.575]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.575]                 }
[01:29:26.575]                 NAMES <- toupper(added)
[01:29:26.575]                 for (kk in seq_along(NAMES)) {
[01:29:26.575]                   name <- added[[kk]]
[01:29:26.575]                   NAME <- NAMES[[kk]]
[01:29:26.575]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.575]                     next
[01:29:26.575]                   args[[name]] <- ""
[01:29:26.575]                 }
[01:29:26.575]                 NAMES <- toupper(removed)
[01:29:26.575]                 for (kk in seq_along(NAMES)) {
[01:29:26.575]                   name <- removed[[kk]]
[01:29:26.575]                   NAME <- NAMES[[kk]]
[01:29:26.575]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.575]                     next
[01:29:26.575]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.575]                 }
[01:29:26.575]                 if (length(args) > 0) 
[01:29:26.575]                   base::do.call(base::Sys.setenv, args = args)
[01:29:26.575]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:26.575]             }
[01:29:26.575]             else {
[01:29:26.575]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:26.575]             }
[01:29:26.575]             {
[01:29:26.575]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:26.575]                   0L) {
[01:29:26.575]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:26.575]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:26.575]                   base::options(opts)
[01:29:26.575]                 }
[01:29:26.575]                 {
[01:29:26.575]                   {
[01:29:26.575]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:26.575]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:26.575]                     -1344458670L), envir = base::globalenv(), 
[01:29:26.575]                       inherits = FALSE)
[01:29:26.575]                     NULL
[01:29:26.575]                   }
[01:29:26.575]                   options(future.plan = NULL)
[01:29:26.575]                   if (is.na(NA_character_)) 
[01:29:26.575]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.575]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:26.575]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:26.575]                   {
[01:29:26.575]                     future <- SequentialFuture(..., envir = envir)
[01:29:26.575]                     if (!future$lazy) 
[01:29:26.575]                       future <- run(future)
[01:29:26.575]                     invisible(future)
[01:29:26.575]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:26.575]                 }
[01:29:26.575]             }
[01:29:26.575]         }
[01:29:26.575]     })
[01:29:26.575]     if (TRUE) {
[01:29:26.575]         base::sink(type = "output", split = FALSE)
[01:29:26.575]         if (TRUE) {
[01:29:26.575]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:26.575]         }
[01:29:26.575]         else {
[01:29:26.575]             ...future.result["stdout"] <- base::list(NULL)
[01:29:26.575]         }
[01:29:26.575]         base::close(...future.stdout)
[01:29:26.575]         ...future.stdout <- NULL
[01:29:26.575]     }
[01:29:26.575]     ...future.result$conditions <- ...future.conditions
[01:29:26.575]     ...future.result$finished <- base::Sys.time()
[01:29:26.575]     ...future.result
[01:29:26.575] }
[01:29:26.580] assign_globals() ...
[01:29:26.580] List of 1
[01:29:26.580]  $ x: int [1:4] 0 1 2 3
[01:29:26.580]  - attr(*, "where")=List of 1
[01:29:26.580]   ..$ x:<environment: R_EmptyEnv> 
[01:29:26.580]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:26.580]  - attr(*, "resolved")= logi FALSE
[01:29:26.580]  - attr(*, "total_size")= num 64
[01:29:26.580]  - attr(*, "already-done")= logi TRUE
[01:29:26.587] - copied 'x' to environment
[01:29:26.587] assign_globals() ... done
[01:29:26.588] plan(): Setting new future strategy stack:
[01:29:26.588] List of future strategies:
[01:29:26.588] 1. sequential:
[01:29:26.588]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.588]    - tweaked: FALSE
[01:29:26.588]    - call: NULL
[01:29:26.589] plan(): nbrOfWorkers() = 1
[01:29:26.591] plan(): Setting new future strategy stack:
[01:29:26.592] List of future strategies:
[01:29:26.592] 1. sequential:
[01:29:26.592]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.592]    - tweaked: FALSE
[01:29:26.592]    - call: plan("sequential")
[01:29:26.592] plan(): nbrOfWorkers() = 1
[01:29:26.592] SequentialFuture started (and completed)
[01:29:26.593] - Launch lazy future ... done
[01:29:26.593] run() for 'SequentialFuture' ... done
[01:29:26.594] getGlobalsAndPackages() ...
[01:29:26.594] Searching for globals...
[01:29:26.595] - globals found: [3] '{', 'sample', 'x'
[01:29:26.595] Searching for globals ... DONE
[01:29:26.596] Resolving globals: FALSE
[01:29:26.599] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:26.599] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:26.600] - globals: [1] 'x'
[01:29:26.600] 
[01:29:26.600] getGlobalsAndPackages() ... DONE
[01:29:26.600] run() for 'Future' ...
[01:29:26.601] - state: 'created'
[01:29:26.601] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:26.601] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:26.601] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:26.602]   - Field: 'label'
[01:29:26.602]   - Field: 'local'
[01:29:26.602]   - Field: 'owner'
[01:29:26.602]   - Field: 'envir'
[01:29:26.603]   - Field: 'packages'
[01:29:26.603]   - Field: 'gc'
[01:29:26.603]   - Field: 'conditions'
[01:29:26.603]   - Field: 'expr'
[01:29:26.603]   - Field: 'uuid'
[01:29:26.604]   - Field: 'seed'
[01:29:26.604]   - Field: 'version'
[01:29:26.604]   - Field: 'result'
[01:29:26.604]   - Field: 'asynchronous'
[01:29:26.604]   - Field: 'calls'
[01:29:26.605]   - Field: 'globals'
[01:29:26.605]   - Field: 'stdout'
[01:29:26.605]   - Field: 'earlySignal'
[01:29:26.605]   - Field: 'lazy'
[01:29:26.605]   - Field: 'state'
[01:29:26.605] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:26.606] - Launch lazy future ...
[01:29:26.606] Packages needed by the future expression (n = 0): <none>
[01:29:26.606] Packages needed by future strategies (n = 0): <none>
[01:29:26.607] {
[01:29:26.607]     {
[01:29:26.607]         {
[01:29:26.607]             ...future.startTime <- base::Sys.time()
[01:29:26.607]             {
[01:29:26.607]                 {
[01:29:26.607]                   {
[01:29:26.607]                     {
[01:29:26.607]                       base::local({
[01:29:26.607]                         has_future <- base::requireNamespace("future", 
[01:29:26.607]                           quietly = TRUE)
[01:29:26.607]                         if (has_future) {
[01:29:26.607]                           ns <- base::getNamespace("future")
[01:29:26.607]                           version <- ns[[".package"]][["version"]]
[01:29:26.607]                           if (is.null(version)) 
[01:29:26.607]                             version <- utils::packageVersion("future")
[01:29:26.607]                         }
[01:29:26.607]                         else {
[01:29:26.607]                           version <- NULL
[01:29:26.607]                         }
[01:29:26.607]                         if (!has_future || version < "1.8.0") {
[01:29:26.607]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:26.607]                             "", base::R.version$version.string), 
[01:29:26.607]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:26.607]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:26.607]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:26.607]                               "release", "version")], collapse = " "), 
[01:29:26.607]                             hostname = base::Sys.info()[["nodename"]])
[01:29:26.607]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:26.607]                             info)
[01:29:26.607]                           info <- base::paste(info, collapse = "; ")
[01:29:26.607]                           if (!has_future) {
[01:29:26.607]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:26.607]                               info)
[01:29:26.607]                           }
[01:29:26.607]                           else {
[01:29:26.607]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:26.607]                               info, version)
[01:29:26.607]                           }
[01:29:26.607]                           base::stop(msg)
[01:29:26.607]                         }
[01:29:26.607]                       })
[01:29:26.607]                     }
[01:29:26.607]                     options(future.plan = NULL)
[01:29:26.607]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.607]                     future::plan("default", .cleanup = FALSE, 
[01:29:26.607]                       .init = FALSE)
[01:29:26.607]                   }
[01:29:26.607]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[01:29:26.607]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[01:29:26.607]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[01:29:26.607]                 }
[01:29:26.607]                 ...future.workdir <- getwd()
[01:29:26.607]             }
[01:29:26.607]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:26.607]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:26.607]         }
[01:29:26.607]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:26.607]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:26.607]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:26.607]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:26.607]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:26.607]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:26.607]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:26.607]             base::names(...future.oldOptions))
[01:29:26.607]     }
[01:29:26.607]     if (FALSE) {
[01:29:26.607]     }
[01:29:26.607]     else {
[01:29:26.607]         if (TRUE) {
[01:29:26.607]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:26.607]                 open = "w")
[01:29:26.607]         }
[01:29:26.607]         else {
[01:29:26.607]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:26.607]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:26.607]         }
[01:29:26.607]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:26.607]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:26.607]             base::sink(type = "output", split = FALSE)
[01:29:26.607]             base::close(...future.stdout)
[01:29:26.607]         }, add = TRUE)
[01:29:26.607]     }
[01:29:26.607]     ...future.frame <- base::sys.nframe()
[01:29:26.607]     ...future.conditions <- base::list()
[01:29:26.607]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:26.607]     if (FALSE) {
[01:29:26.607]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:26.607]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:26.607]     }
[01:29:26.607]     ...future.result <- base::tryCatch({
[01:29:26.607]         base::withCallingHandlers({
[01:29:26.607]             ...future.value <- base::withVisible(base::local({
[01:29:26.607]                 sample(x, size = 1L)
[01:29:26.607]             }))
[01:29:26.607]             future::FutureResult(value = ...future.value$value, 
[01:29:26.607]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.607]                   ...future.rng), globalenv = if (FALSE) 
[01:29:26.607]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:26.607]                     ...future.globalenv.names))
[01:29:26.607]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:26.607]         }, condition = base::local({
[01:29:26.607]             c <- base::c
[01:29:26.607]             inherits <- base::inherits
[01:29:26.607]             invokeRestart <- base::invokeRestart
[01:29:26.607]             length <- base::length
[01:29:26.607]             list <- base::list
[01:29:26.607]             seq.int <- base::seq.int
[01:29:26.607]             signalCondition <- base::signalCondition
[01:29:26.607]             sys.calls <- base::sys.calls
[01:29:26.607]             `[[` <- base::`[[`
[01:29:26.607]             `+` <- base::`+`
[01:29:26.607]             `<<-` <- base::`<<-`
[01:29:26.607]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:26.607]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:26.607]                   3L)]
[01:29:26.607]             }
[01:29:26.607]             function(cond) {
[01:29:26.607]                 is_error <- inherits(cond, "error")
[01:29:26.607]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:26.607]                   NULL)
[01:29:26.607]                 if (is_error) {
[01:29:26.607]                   sessionInformation <- function() {
[01:29:26.607]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:26.607]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:26.607]                       search = base::search(), system = base::Sys.info())
[01:29:26.607]                   }
[01:29:26.607]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.607]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:26.607]                     cond$call), session = sessionInformation(), 
[01:29:26.607]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:26.607]                   signalCondition(cond)
[01:29:26.607]                 }
[01:29:26.607]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:26.607]                 "immediateCondition"))) {
[01:29:26.607]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:26.607]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.607]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:26.607]                   if (TRUE && !signal) {
[01:29:26.607]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.607]                     {
[01:29:26.607]                       inherits <- base::inherits
[01:29:26.607]                       invokeRestart <- base::invokeRestart
[01:29:26.607]                       is.null <- base::is.null
[01:29:26.607]                       muffled <- FALSE
[01:29:26.607]                       if (inherits(cond, "message")) {
[01:29:26.607]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.607]                         if (muffled) 
[01:29:26.607]                           invokeRestart("muffleMessage")
[01:29:26.607]                       }
[01:29:26.607]                       else if (inherits(cond, "warning")) {
[01:29:26.607]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.607]                         if (muffled) 
[01:29:26.607]                           invokeRestart("muffleWarning")
[01:29:26.607]                       }
[01:29:26.607]                       else if (inherits(cond, "condition")) {
[01:29:26.607]                         if (!is.null(pattern)) {
[01:29:26.607]                           computeRestarts <- base::computeRestarts
[01:29:26.607]                           grepl <- base::grepl
[01:29:26.607]                           restarts <- computeRestarts(cond)
[01:29:26.607]                           for (restart in restarts) {
[01:29:26.607]                             name <- restart$name
[01:29:26.607]                             if (is.null(name)) 
[01:29:26.607]                               next
[01:29:26.607]                             if (!grepl(pattern, name)) 
[01:29:26.607]                               next
[01:29:26.607]                             invokeRestart(restart)
[01:29:26.607]                             muffled <- TRUE
[01:29:26.607]                             break
[01:29:26.607]                           }
[01:29:26.607]                         }
[01:29:26.607]                       }
[01:29:26.607]                       invisible(muffled)
[01:29:26.607]                     }
[01:29:26.607]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.607]                   }
[01:29:26.607]                 }
[01:29:26.607]                 else {
[01:29:26.607]                   if (TRUE) {
[01:29:26.607]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.607]                     {
[01:29:26.607]                       inherits <- base::inherits
[01:29:26.607]                       invokeRestart <- base::invokeRestart
[01:29:26.607]                       is.null <- base::is.null
[01:29:26.607]                       muffled <- FALSE
[01:29:26.607]                       if (inherits(cond, "message")) {
[01:29:26.607]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.607]                         if (muffled) 
[01:29:26.607]                           invokeRestart("muffleMessage")
[01:29:26.607]                       }
[01:29:26.607]                       else if (inherits(cond, "warning")) {
[01:29:26.607]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.607]                         if (muffled) 
[01:29:26.607]                           invokeRestart("muffleWarning")
[01:29:26.607]                       }
[01:29:26.607]                       else if (inherits(cond, "condition")) {
[01:29:26.607]                         if (!is.null(pattern)) {
[01:29:26.607]                           computeRestarts <- base::computeRestarts
[01:29:26.607]                           grepl <- base::grepl
[01:29:26.607]                           restarts <- computeRestarts(cond)
[01:29:26.607]                           for (restart in restarts) {
[01:29:26.607]                             name <- restart$name
[01:29:26.607]                             if (is.null(name)) 
[01:29:26.607]                               next
[01:29:26.607]                             if (!grepl(pattern, name)) 
[01:29:26.607]                               next
[01:29:26.607]                             invokeRestart(restart)
[01:29:26.607]                             muffled <- TRUE
[01:29:26.607]                             break
[01:29:26.607]                           }
[01:29:26.607]                         }
[01:29:26.607]                       }
[01:29:26.607]                       invisible(muffled)
[01:29:26.607]                     }
[01:29:26.607]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.607]                   }
[01:29:26.607]                 }
[01:29:26.607]             }
[01:29:26.607]         }))
[01:29:26.607]     }, error = function(ex) {
[01:29:26.607]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:26.607]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.607]                 ...future.rng), started = ...future.startTime, 
[01:29:26.607]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:26.607]             version = "1.8"), class = "FutureResult")
[01:29:26.607]     }, finally = {
[01:29:26.607]         if (!identical(...future.workdir, getwd())) 
[01:29:26.607]             setwd(...future.workdir)
[01:29:26.607]         {
[01:29:26.607]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:26.607]                 ...future.oldOptions$nwarnings <- NULL
[01:29:26.607]             }
[01:29:26.607]             base::options(...future.oldOptions)
[01:29:26.607]             if (.Platform$OS.type == "windows") {
[01:29:26.607]                 old_names <- names(...future.oldEnvVars)
[01:29:26.607]                 envs <- base::Sys.getenv()
[01:29:26.607]                 names <- names(envs)
[01:29:26.607]                 common <- intersect(names, old_names)
[01:29:26.607]                 added <- setdiff(names, old_names)
[01:29:26.607]                 removed <- setdiff(old_names, names)
[01:29:26.607]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:26.607]                   envs[common]]
[01:29:26.607]                 NAMES <- toupper(changed)
[01:29:26.607]                 args <- list()
[01:29:26.607]                 for (kk in seq_along(NAMES)) {
[01:29:26.607]                   name <- changed[[kk]]
[01:29:26.607]                   NAME <- NAMES[[kk]]
[01:29:26.607]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.607]                     next
[01:29:26.607]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.607]                 }
[01:29:26.607]                 NAMES <- toupper(added)
[01:29:26.607]                 for (kk in seq_along(NAMES)) {
[01:29:26.607]                   name <- added[[kk]]
[01:29:26.607]                   NAME <- NAMES[[kk]]
[01:29:26.607]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.607]                     next
[01:29:26.607]                   args[[name]] <- ""
[01:29:26.607]                 }
[01:29:26.607]                 NAMES <- toupper(removed)
[01:29:26.607]                 for (kk in seq_along(NAMES)) {
[01:29:26.607]                   name <- removed[[kk]]
[01:29:26.607]                   NAME <- NAMES[[kk]]
[01:29:26.607]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.607]                     next
[01:29:26.607]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.607]                 }
[01:29:26.607]                 if (length(args) > 0) 
[01:29:26.607]                   base::do.call(base::Sys.setenv, args = args)
[01:29:26.607]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:26.607]             }
[01:29:26.607]             else {
[01:29:26.607]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:26.607]             }
[01:29:26.607]             {
[01:29:26.607]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:26.607]                   0L) {
[01:29:26.607]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:26.607]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:26.607]                   base::options(opts)
[01:29:26.607]                 }
[01:29:26.607]                 {
[01:29:26.607]                   {
[01:29:26.607]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:26.607]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:26.607]                     -1344458670L), envir = base::globalenv(), 
[01:29:26.607]                       inherits = FALSE)
[01:29:26.607]                     NULL
[01:29:26.607]                   }
[01:29:26.607]                   options(future.plan = NULL)
[01:29:26.607]                   if (is.na(NA_character_)) 
[01:29:26.607]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.607]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:26.607]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:26.607]                   {
[01:29:26.607]                     future <- SequentialFuture(..., envir = envir)
[01:29:26.607]                     if (!future$lazy) 
[01:29:26.607]                       future <- run(future)
[01:29:26.607]                     invisible(future)
[01:29:26.607]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:26.607]                 }
[01:29:26.607]             }
[01:29:26.607]         }
[01:29:26.607]     })
[01:29:26.607]     if (TRUE) {
[01:29:26.607]         base::sink(type = "output", split = FALSE)
[01:29:26.607]         if (TRUE) {
[01:29:26.607]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:26.607]         }
[01:29:26.607]         else {
[01:29:26.607]             ...future.result["stdout"] <- base::list(NULL)
[01:29:26.607]         }
[01:29:26.607]         base::close(...future.stdout)
[01:29:26.607]         ...future.stdout <- NULL
[01:29:26.607]     }
[01:29:26.607]     ...future.result$conditions <- ...future.conditions
[01:29:26.607]     ...future.result$finished <- base::Sys.time()
[01:29:26.607]     ...future.result
[01:29:26.607] }
[01:29:26.611] assign_globals() ...
[01:29:26.611] List of 1
[01:29:26.611]  $ x: int [1:4] 0 1 2 3
[01:29:26.611]  - attr(*, "where")=List of 1
[01:29:26.611]   ..$ x:<environment: R_EmptyEnv> 
[01:29:26.611]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:26.611]  - attr(*, "resolved")= logi FALSE
[01:29:26.611]  - attr(*, "total_size")= num 64
[01:29:26.611]  - attr(*, "already-done")= logi TRUE
[01:29:26.614] - copied 'x' to environment
[01:29:26.614] assign_globals() ... done
[01:29:26.615] plan(): Setting new future strategy stack:
[01:29:26.615] List of future strategies:
[01:29:26.615] 1. sequential:
[01:29:26.615]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.615]    - tweaked: FALSE
[01:29:26.615]    - call: NULL
[01:29:26.615] plan(): nbrOfWorkers() = 1
[01:29:26.617] plan(): Setting new future strategy stack:
[01:29:26.617] List of future strategies:
[01:29:26.617] 1. sequential:
[01:29:26.617]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.617]    - tweaked: FALSE
[01:29:26.617]    - call: plan("sequential")
[01:29:26.618] plan(): nbrOfWorkers() = 1
[01:29:26.618] SequentialFuture started (and completed)
[01:29:26.618] - Launch lazy future ... done
[01:29:26.618] run() for 'SequentialFuture' ... done
[01:29:26.618] getGlobalsAndPackages() ...
[01:29:26.619] Searching for globals...
[01:29:26.620] - globals found: [3] '{', 'sample', 'x'
[01:29:26.620] Searching for globals ... DONE
[01:29:26.620] Resolving globals: FALSE
[01:29:26.621] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:26.621] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:26.621] - globals: [1] 'x'
[01:29:26.622] 
[01:29:26.622] getGlobalsAndPackages() ... DONE
[01:29:26.622] run() for 'Future' ...
[01:29:26.622] - state: 'created'
[01:29:26.622] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:26.623] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:26.623] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:26.623]   - Field: 'label'
[01:29:26.623]   - Field: 'local'
[01:29:26.624]   - Field: 'owner'
[01:29:26.624]   - Field: 'envir'
[01:29:26.624]   - Field: 'packages'
[01:29:26.624]   - Field: 'gc'
[01:29:26.624]   - Field: 'conditions'
[01:29:26.624]   - Field: 'expr'
[01:29:26.625]   - Field: 'uuid'
[01:29:26.625]   - Field: 'seed'
[01:29:26.625]   - Field: 'version'
[01:29:26.625]   - Field: 'result'
[01:29:26.625]   - Field: 'asynchronous'
[01:29:26.626]   - Field: 'calls'
[01:29:26.626]   - Field: 'globals'
[01:29:26.626]   - Field: 'stdout'
[01:29:26.626]   - Field: 'earlySignal'
[01:29:26.626]   - Field: 'lazy'
[01:29:26.626]   - Field: 'state'
[01:29:26.627] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:26.627] - Launch lazy future ...
[01:29:26.627] Packages needed by the future expression (n = 0): <none>
[01:29:26.627] Packages needed by future strategies (n = 0): <none>
[01:29:26.628] {
[01:29:26.628]     {
[01:29:26.628]         {
[01:29:26.628]             ...future.startTime <- base::Sys.time()
[01:29:26.628]             {
[01:29:26.628]                 {
[01:29:26.628]                   {
[01:29:26.628]                     {
[01:29:26.628]                       base::local({
[01:29:26.628]                         has_future <- base::requireNamespace("future", 
[01:29:26.628]                           quietly = TRUE)
[01:29:26.628]                         if (has_future) {
[01:29:26.628]                           ns <- base::getNamespace("future")
[01:29:26.628]                           version <- ns[[".package"]][["version"]]
[01:29:26.628]                           if (is.null(version)) 
[01:29:26.628]                             version <- utils::packageVersion("future")
[01:29:26.628]                         }
[01:29:26.628]                         else {
[01:29:26.628]                           version <- NULL
[01:29:26.628]                         }
[01:29:26.628]                         if (!has_future || version < "1.8.0") {
[01:29:26.628]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:26.628]                             "", base::R.version$version.string), 
[01:29:26.628]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:26.628]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:26.628]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:26.628]                               "release", "version")], collapse = " "), 
[01:29:26.628]                             hostname = base::Sys.info()[["nodename"]])
[01:29:26.628]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:26.628]                             info)
[01:29:26.628]                           info <- base::paste(info, collapse = "; ")
[01:29:26.628]                           if (!has_future) {
[01:29:26.628]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:26.628]                               info)
[01:29:26.628]                           }
[01:29:26.628]                           else {
[01:29:26.628]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:26.628]                               info, version)
[01:29:26.628]                           }
[01:29:26.628]                           base::stop(msg)
[01:29:26.628]                         }
[01:29:26.628]                       })
[01:29:26.628]                     }
[01:29:26.628]                     options(future.plan = NULL)
[01:29:26.628]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.628]                     future::plan("default", .cleanup = FALSE, 
[01:29:26.628]                       .init = FALSE)
[01:29:26.628]                   }
[01:29:26.628]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[01:29:26.628]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[01:29:26.628]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[01:29:26.628]                 }
[01:29:26.628]                 ...future.workdir <- getwd()
[01:29:26.628]             }
[01:29:26.628]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:26.628]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:26.628]         }
[01:29:26.628]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:26.628]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:26.628]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:26.628]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:26.628]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:26.628]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:26.628]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:26.628]             base::names(...future.oldOptions))
[01:29:26.628]     }
[01:29:26.628]     if (FALSE) {
[01:29:26.628]     }
[01:29:26.628]     else {
[01:29:26.628]         if (TRUE) {
[01:29:26.628]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:26.628]                 open = "w")
[01:29:26.628]         }
[01:29:26.628]         else {
[01:29:26.628]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:26.628]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:26.628]         }
[01:29:26.628]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:26.628]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:26.628]             base::sink(type = "output", split = FALSE)
[01:29:26.628]             base::close(...future.stdout)
[01:29:26.628]         }, add = TRUE)
[01:29:26.628]     }
[01:29:26.628]     ...future.frame <- base::sys.nframe()
[01:29:26.628]     ...future.conditions <- base::list()
[01:29:26.628]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:26.628]     if (FALSE) {
[01:29:26.628]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:26.628]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:26.628]     }
[01:29:26.628]     ...future.result <- base::tryCatch({
[01:29:26.628]         base::withCallingHandlers({
[01:29:26.628]             ...future.value <- base::withVisible(base::local({
[01:29:26.628]                 sample(x, size = 1L)
[01:29:26.628]             }))
[01:29:26.628]             future::FutureResult(value = ...future.value$value, 
[01:29:26.628]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.628]                   ...future.rng), globalenv = if (FALSE) 
[01:29:26.628]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:26.628]                     ...future.globalenv.names))
[01:29:26.628]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:26.628]         }, condition = base::local({
[01:29:26.628]             c <- base::c
[01:29:26.628]             inherits <- base::inherits
[01:29:26.628]             invokeRestart <- base::invokeRestart
[01:29:26.628]             length <- base::length
[01:29:26.628]             list <- base::list
[01:29:26.628]             seq.int <- base::seq.int
[01:29:26.628]             signalCondition <- base::signalCondition
[01:29:26.628]             sys.calls <- base::sys.calls
[01:29:26.628]             `[[` <- base::`[[`
[01:29:26.628]             `+` <- base::`+`
[01:29:26.628]             `<<-` <- base::`<<-`
[01:29:26.628]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:26.628]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:26.628]                   3L)]
[01:29:26.628]             }
[01:29:26.628]             function(cond) {
[01:29:26.628]                 is_error <- inherits(cond, "error")
[01:29:26.628]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:26.628]                   NULL)
[01:29:26.628]                 if (is_error) {
[01:29:26.628]                   sessionInformation <- function() {
[01:29:26.628]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:26.628]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:26.628]                       search = base::search(), system = base::Sys.info())
[01:29:26.628]                   }
[01:29:26.628]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.628]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:26.628]                     cond$call), session = sessionInformation(), 
[01:29:26.628]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:26.628]                   signalCondition(cond)
[01:29:26.628]                 }
[01:29:26.628]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:26.628]                 "immediateCondition"))) {
[01:29:26.628]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:26.628]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.628]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:26.628]                   if (TRUE && !signal) {
[01:29:26.628]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.628]                     {
[01:29:26.628]                       inherits <- base::inherits
[01:29:26.628]                       invokeRestart <- base::invokeRestart
[01:29:26.628]                       is.null <- base::is.null
[01:29:26.628]                       muffled <- FALSE
[01:29:26.628]                       if (inherits(cond, "message")) {
[01:29:26.628]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.628]                         if (muffled) 
[01:29:26.628]                           invokeRestart("muffleMessage")
[01:29:26.628]                       }
[01:29:26.628]                       else if (inherits(cond, "warning")) {
[01:29:26.628]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.628]                         if (muffled) 
[01:29:26.628]                           invokeRestart("muffleWarning")
[01:29:26.628]                       }
[01:29:26.628]                       else if (inherits(cond, "condition")) {
[01:29:26.628]                         if (!is.null(pattern)) {
[01:29:26.628]                           computeRestarts <- base::computeRestarts
[01:29:26.628]                           grepl <- base::grepl
[01:29:26.628]                           restarts <- computeRestarts(cond)
[01:29:26.628]                           for (restart in restarts) {
[01:29:26.628]                             name <- restart$name
[01:29:26.628]                             if (is.null(name)) 
[01:29:26.628]                               next
[01:29:26.628]                             if (!grepl(pattern, name)) 
[01:29:26.628]                               next
[01:29:26.628]                             invokeRestart(restart)
[01:29:26.628]                             muffled <- TRUE
[01:29:26.628]                             break
[01:29:26.628]                           }
[01:29:26.628]                         }
[01:29:26.628]                       }
[01:29:26.628]                       invisible(muffled)
[01:29:26.628]                     }
[01:29:26.628]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.628]                   }
[01:29:26.628]                 }
[01:29:26.628]                 else {
[01:29:26.628]                   if (TRUE) {
[01:29:26.628]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.628]                     {
[01:29:26.628]                       inherits <- base::inherits
[01:29:26.628]                       invokeRestart <- base::invokeRestart
[01:29:26.628]                       is.null <- base::is.null
[01:29:26.628]                       muffled <- FALSE
[01:29:26.628]                       if (inherits(cond, "message")) {
[01:29:26.628]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.628]                         if (muffled) 
[01:29:26.628]                           invokeRestart("muffleMessage")
[01:29:26.628]                       }
[01:29:26.628]                       else if (inherits(cond, "warning")) {
[01:29:26.628]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.628]                         if (muffled) 
[01:29:26.628]                           invokeRestart("muffleWarning")
[01:29:26.628]                       }
[01:29:26.628]                       else if (inherits(cond, "condition")) {
[01:29:26.628]                         if (!is.null(pattern)) {
[01:29:26.628]                           computeRestarts <- base::computeRestarts
[01:29:26.628]                           grepl <- base::grepl
[01:29:26.628]                           restarts <- computeRestarts(cond)
[01:29:26.628]                           for (restart in restarts) {
[01:29:26.628]                             name <- restart$name
[01:29:26.628]                             if (is.null(name)) 
[01:29:26.628]                               next
[01:29:26.628]                             if (!grepl(pattern, name)) 
[01:29:26.628]                               next
[01:29:26.628]                             invokeRestart(restart)
[01:29:26.628]                             muffled <- TRUE
[01:29:26.628]                             break
[01:29:26.628]                           }
[01:29:26.628]                         }
[01:29:26.628]                       }
[01:29:26.628]                       invisible(muffled)
[01:29:26.628]                     }
[01:29:26.628]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.628]                   }
[01:29:26.628]                 }
[01:29:26.628]             }
[01:29:26.628]         }))
[01:29:26.628]     }, error = function(ex) {
[01:29:26.628]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:26.628]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.628]                 ...future.rng), started = ...future.startTime, 
[01:29:26.628]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:26.628]             version = "1.8"), class = "FutureResult")
[01:29:26.628]     }, finally = {
[01:29:26.628]         if (!identical(...future.workdir, getwd())) 
[01:29:26.628]             setwd(...future.workdir)
[01:29:26.628]         {
[01:29:26.628]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:26.628]                 ...future.oldOptions$nwarnings <- NULL
[01:29:26.628]             }
[01:29:26.628]             base::options(...future.oldOptions)
[01:29:26.628]             if (.Platform$OS.type == "windows") {
[01:29:26.628]                 old_names <- names(...future.oldEnvVars)
[01:29:26.628]                 envs <- base::Sys.getenv()
[01:29:26.628]                 names <- names(envs)
[01:29:26.628]                 common <- intersect(names, old_names)
[01:29:26.628]                 added <- setdiff(names, old_names)
[01:29:26.628]                 removed <- setdiff(old_names, names)
[01:29:26.628]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:26.628]                   envs[common]]
[01:29:26.628]                 NAMES <- toupper(changed)
[01:29:26.628]                 args <- list()
[01:29:26.628]                 for (kk in seq_along(NAMES)) {
[01:29:26.628]                   name <- changed[[kk]]
[01:29:26.628]                   NAME <- NAMES[[kk]]
[01:29:26.628]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.628]                     next
[01:29:26.628]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.628]                 }
[01:29:26.628]                 NAMES <- toupper(added)
[01:29:26.628]                 for (kk in seq_along(NAMES)) {
[01:29:26.628]                   name <- added[[kk]]
[01:29:26.628]                   NAME <- NAMES[[kk]]
[01:29:26.628]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.628]                     next
[01:29:26.628]                   args[[name]] <- ""
[01:29:26.628]                 }
[01:29:26.628]                 NAMES <- toupper(removed)
[01:29:26.628]                 for (kk in seq_along(NAMES)) {
[01:29:26.628]                   name <- removed[[kk]]
[01:29:26.628]                   NAME <- NAMES[[kk]]
[01:29:26.628]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.628]                     next
[01:29:26.628]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.628]                 }
[01:29:26.628]                 if (length(args) > 0) 
[01:29:26.628]                   base::do.call(base::Sys.setenv, args = args)
[01:29:26.628]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:26.628]             }
[01:29:26.628]             else {
[01:29:26.628]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:26.628]             }
[01:29:26.628]             {
[01:29:26.628]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:26.628]                   0L) {
[01:29:26.628]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:26.628]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:26.628]                   base::options(opts)
[01:29:26.628]                 }
[01:29:26.628]                 {
[01:29:26.628]                   {
[01:29:26.628]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:26.628]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:26.628]                     -1344458670L), envir = base::globalenv(), 
[01:29:26.628]                       inherits = FALSE)
[01:29:26.628]                     NULL
[01:29:26.628]                   }
[01:29:26.628]                   options(future.plan = NULL)
[01:29:26.628]                   if (is.na(NA_character_)) 
[01:29:26.628]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.628]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:26.628]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:26.628]                   {
[01:29:26.628]                     future <- SequentialFuture(..., envir = envir)
[01:29:26.628]                     if (!future$lazy) 
[01:29:26.628]                       future <- run(future)
[01:29:26.628]                     invisible(future)
[01:29:26.628]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:26.628]                 }
[01:29:26.628]             }
[01:29:26.628]         }
[01:29:26.628]     })
[01:29:26.628]     if (TRUE) {
[01:29:26.628]         base::sink(type = "output", split = FALSE)
[01:29:26.628]         if (TRUE) {
[01:29:26.628]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:26.628]         }
[01:29:26.628]         else {
[01:29:26.628]             ...future.result["stdout"] <- base::list(NULL)
[01:29:26.628]         }
[01:29:26.628]         base::close(...future.stdout)
[01:29:26.628]         ...future.stdout <- NULL
[01:29:26.628]     }
[01:29:26.628]     ...future.result$conditions <- ...future.conditions
[01:29:26.628]     ...future.result$finished <- base::Sys.time()
[01:29:26.628]     ...future.result
[01:29:26.628] }
[01:29:26.632] assign_globals() ...
[01:29:26.632] List of 1
[01:29:26.632]  $ x: int [1:4] 0 1 2 3
[01:29:26.632]  - attr(*, "where")=List of 1
[01:29:26.632]   ..$ x:<environment: R_EmptyEnv> 
[01:29:26.632]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:26.632]  - attr(*, "resolved")= logi FALSE
[01:29:26.632]  - attr(*, "total_size")= num 64
[01:29:26.632]  - attr(*, "already-done")= logi TRUE
[01:29:26.635] - copied 'x' to environment
[01:29:26.636] assign_globals() ... done
[01:29:26.636] plan(): Setting new future strategy stack:
[01:29:26.636] List of future strategies:
[01:29:26.636] 1. sequential:
[01:29:26.636]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.636]    - tweaked: FALSE
[01:29:26.636]    - call: NULL
[01:29:26.637] plan(): nbrOfWorkers() = 1
[01:29:26.638] plan(): Setting new future strategy stack:
[01:29:26.638] List of future strategies:
[01:29:26.638] 1. sequential:
[01:29:26.638]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.638]    - tweaked: FALSE
[01:29:26.638]    - call: plan("sequential")
[01:29:26.639] plan(): nbrOfWorkers() = 1
[01:29:26.641] SequentialFuture started (and completed)
[01:29:26.641] - Launch lazy future ... done
[01:29:26.641] run() for 'SequentialFuture' ... done
[01:29:26.641] getGlobalsAndPackages() ...
[01:29:26.642] Searching for globals...
[01:29:26.643] - globals found: [3] '{', 'sample', 'x'
[01:29:26.643] Searching for globals ... DONE
[01:29:26.643] Resolving globals: FALSE
[01:29:26.644] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:26.644] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:26.645] - globals: [1] 'x'
[01:29:26.645] 
[01:29:26.645] getGlobalsAndPackages() ... DONE
[01:29:26.645] run() for 'Future' ...
[01:29:26.645] - state: 'created'
[01:29:26.646] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:26.646] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:26.646] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:26.646]   - Field: 'label'
[01:29:26.647]   - Field: 'local'
[01:29:26.647]   - Field: 'owner'
[01:29:26.647]   - Field: 'envir'
[01:29:26.647]   - Field: 'packages'
[01:29:26.647]   - Field: 'gc'
[01:29:26.648]   - Field: 'conditions'
[01:29:26.648]   - Field: 'expr'
[01:29:26.648]   - Field: 'uuid'
[01:29:26.648]   - Field: 'seed'
[01:29:26.648]   - Field: 'version'
[01:29:26.648]   - Field: 'result'
[01:29:26.649]   - Field: 'asynchronous'
[01:29:26.649]   - Field: 'calls'
[01:29:26.649]   - Field: 'globals'
[01:29:26.649]   - Field: 'stdout'
[01:29:26.649]   - Field: 'earlySignal'
[01:29:26.650]   - Field: 'lazy'
[01:29:26.650]   - Field: 'state'
[01:29:26.650] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:26.650] - Launch lazy future ...
[01:29:26.650] Packages needed by the future expression (n = 0): <none>
[01:29:26.651] Packages needed by future strategies (n = 0): <none>
[01:29:26.651] {
[01:29:26.651]     {
[01:29:26.651]         {
[01:29:26.651]             ...future.startTime <- base::Sys.time()
[01:29:26.651]             {
[01:29:26.651]                 {
[01:29:26.651]                   {
[01:29:26.651]                     {
[01:29:26.651]                       base::local({
[01:29:26.651]                         has_future <- base::requireNamespace("future", 
[01:29:26.651]                           quietly = TRUE)
[01:29:26.651]                         if (has_future) {
[01:29:26.651]                           ns <- base::getNamespace("future")
[01:29:26.651]                           version <- ns[[".package"]][["version"]]
[01:29:26.651]                           if (is.null(version)) 
[01:29:26.651]                             version <- utils::packageVersion("future")
[01:29:26.651]                         }
[01:29:26.651]                         else {
[01:29:26.651]                           version <- NULL
[01:29:26.651]                         }
[01:29:26.651]                         if (!has_future || version < "1.8.0") {
[01:29:26.651]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:26.651]                             "", base::R.version$version.string), 
[01:29:26.651]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:26.651]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:26.651]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:26.651]                               "release", "version")], collapse = " "), 
[01:29:26.651]                             hostname = base::Sys.info()[["nodename"]])
[01:29:26.651]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:26.651]                             info)
[01:29:26.651]                           info <- base::paste(info, collapse = "; ")
[01:29:26.651]                           if (!has_future) {
[01:29:26.651]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:26.651]                               info)
[01:29:26.651]                           }
[01:29:26.651]                           else {
[01:29:26.651]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:26.651]                               info, version)
[01:29:26.651]                           }
[01:29:26.651]                           base::stop(msg)
[01:29:26.651]                         }
[01:29:26.651]                       })
[01:29:26.651]                     }
[01:29:26.651]                     options(future.plan = NULL)
[01:29:26.651]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.651]                     future::plan("default", .cleanup = FALSE, 
[01:29:26.651]                       .init = FALSE)
[01:29:26.651]                   }
[01:29:26.651]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[01:29:26.651]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[01:29:26.651]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[01:29:26.651]                 }
[01:29:26.651]                 ...future.workdir <- getwd()
[01:29:26.651]             }
[01:29:26.651]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:26.651]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:26.651]         }
[01:29:26.651]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:26.651]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:26.651]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:26.651]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:26.651]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:26.651]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:26.651]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:26.651]             base::names(...future.oldOptions))
[01:29:26.651]     }
[01:29:26.651]     if (FALSE) {
[01:29:26.651]     }
[01:29:26.651]     else {
[01:29:26.651]         if (TRUE) {
[01:29:26.651]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:26.651]                 open = "w")
[01:29:26.651]         }
[01:29:26.651]         else {
[01:29:26.651]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:26.651]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:26.651]         }
[01:29:26.651]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:26.651]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:26.651]             base::sink(type = "output", split = FALSE)
[01:29:26.651]             base::close(...future.stdout)
[01:29:26.651]         }, add = TRUE)
[01:29:26.651]     }
[01:29:26.651]     ...future.frame <- base::sys.nframe()
[01:29:26.651]     ...future.conditions <- base::list()
[01:29:26.651]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:26.651]     if (FALSE) {
[01:29:26.651]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:26.651]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:26.651]     }
[01:29:26.651]     ...future.result <- base::tryCatch({
[01:29:26.651]         base::withCallingHandlers({
[01:29:26.651]             ...future.value <- base::withVisible(base::local({
[01:29:26.651]                 sample(x, size = 1L)
[01:29:26.651]             }))
[01:29:26.651]             future::FutureResult(value = ...future.value$value, 
[01:29:26.651]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.651]                   ...future.rng), globalenv = if (FALSE) 
[01:29:26.651]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:26.651]                     ...future.globalenv.names))
[01:29:26.651]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:26.651]         }, condition = base::local({
[01:29:26.651]             c <- base::c
[01:29:26.651]             inherits <- base::inherits
[01:29:26.651]             invokeRestart <- base::invokeRestart
[01:29:26.651]             length <- base::length
[01:29:26.651]             list <- base::list
[01:29:26.651]             seq.int <- base::seq.int
[01:29:26.651]             signalCondition <- base::signalCondition
[01:29:26.651]             sys.calls <- base::sys.calls
[01:29:26.651]             `[[` <- base::`[[`
[01:29:26.651]             `+` <- base::`+`
[01:29:26.651]             `<<-` <- base::`<<-`
[01:29:26.651]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:26.651]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:26.651]                   3L)]
[01:29:26.651]             }
[01:29:26.651]             function(cond) {
[01:29:26.651]                 is_error <- inherits(cond, "error")
[01:29:26.651]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:26.651]                   NULL)
[01:29:26.651]                 if (is_error) {
[01:29:26.651]                   sessionInformation <- function() {
[01:29:26.651]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:26.651]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:26.651]                       search = base::search(), system = base::Sys.info())
[01:29:26.651]                   }
[01:29:26.651]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.651]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:26.651]                     cond$call), session = sessionInformation(), 
[01:29:26.651]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:26.651]                   signalCondition(cond)
[01:29:26.651]                 }
[01:29:26.651]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:26.651]                 "immediateCondition"))) {
[01:29:26.651]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:26.651]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.651]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:26.651]                   if (TRUE && !signal) {
[01:29:26.651]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.651]                     {
[01:29:26.651]                       inherits <- base::inherits
[01:29:26.651]                       invokeRestart <- base::invokeRestart
[01:29:26.651]                       is.null <- base::is.null
[01:29:26.651]                       muffled <- FALSE
[01:29:26.651]                       if (inherits(cond, "message")) {
[01:29:26.651]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.651]                         if (muffled) 
[01:29:26.651]                           invokeRestart("muffleMessage")
[01:29:26.651]                       }
[01:29:26.651]                       else if (inherits(cond, "warning")) {
[01:29:26.651]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.651]                         if (muffled) 
[01:29:26.651]                           invokeRestart("muffleWarning")
[01:29:26.651]                       }
[01:29:26.651]                       else if (inherits(cond, "condition")) {
[01:29:26.651]                         if (!is.null(pattern)) {
[01:29:26.651]                           computeRestarts <- base::computeRestarts
[01:29:26.651]                           grepl <- base::grepl
[01:29:26.651]                           restarts <- computeRestarts(cond)
[01:29:26.651]                           for (restart in restarts) {
[01:29:26.651]                             name <- restart$name
[01:29:26.651]                             if (is.null(name)) 
[01:29:26.651]                               next
[01:29:26.651]                             if (!grepl(pattern, name)) 
[01:29:26.651]                               next
[01:29:26.651]                             invokeRestart(restart)
[01:29:26.651]                             muffled <- TRUE
[01:29:26.651]                             break
[01:29:26.651]                           }
[01:29:26.651]                         }
[01:29:26.651]                       }
[01:29:26.651]                       invisible(muffled)
[01:29:26.651]                     }
[01:29:26.651]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.651]                   }
[01:29:26.651]                 }
[01:29:26.651]                 else {
[01:29:26.651]                   if (TRUE) {
[01:29:26.651]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.651]                     {
[01:29:26.651]                       inherits <- base::inherits
[01:29:26.651]                       invokeRestart <- base::invokeRestart
[01:29:26.651]                       is.null <- base::is.null
[01:29:26.651]                       muffled <- FALSE
[01:29:26.651]                       if (inherits(cond, "message")) {
[01:29:26.651]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.651]                         if (muffled) 
[01:29:26.651]                           invokeRestart("muffleMessage")
[01:29:26.651]                       }
[01:29:26.651]                       else if (inherits(cond, "warning")) {
[01:29:26.651]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.651]                         if (muffled) 
[01:29:26.651]                           invokeRestart("muffleWarning")
[01:29:26.651]                       }
[01:29:26.651]                       else if (inherits(cond, "condition")) {
[01:29:26.651]                         if (!is.null(pattern)) {
[01:29:26.651]                           computeRestarts <- base::computeRestarts
[01:29:26.651]                           grepl <- base::grepl
[01:29:26.651]                           restarts <- computeRestarts(cond)
[01:29:26.651]                           for (restart in restarts) {
[01:29:26.651]                             name <- restart$name
[01:29:26.651]                             if (is.null(name)) 
[01:29:26.651]                               next
[01:29:26.651]                             if (!grepl(pattern, name)) 
[01:29:26.651]                               next
[01:29:26.651]                             invokeRestart(restart)
[01:29:26.651]                             muffled <- TRUE
[01:29:26.651]                             break
[01:29:26.651]                           }
[01:29:26.651]                         }
[01:29:26.651]                       }
[01:29:26.651]                       invisible(muffled)
[01:29:26.651]                     }
[01:29:26.651]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.651]                   }
[01:29:26.651]                 }
[01:29:26.651]             }
[01:29:26.651]         }))
[01:29:26.651]     }, error = function(ex) {
[01:29:26.651]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:26.651]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.651]                 ...future.rng), started = ...future.startTime, 
[01:29:26.651]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:26.651]             version = "1.8"), class = "FutureResult")
[01:29:26.651]     }, finally = {
[01:29:26.651]         if (!identical(...future.workdir, getwd())) 
[01:29:26.651]             setwd(...future.workdir)
[01:29:26.651]         {
[01:29:26.651]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:26.651]                 ...future.oldOptions$nwarnings <- NULL
[01:29:26.651]             }
[01:29:26.651]             base::options(...future.oldOptions)
[01:29:26.651]             if (.Platform$OS.type == "windows") {
[01:29:26.651]                 old_names <- names(...future.oldEnvVars)
[01:29:26.651]                 envs <- base::Sys.getenv()
[01:29:26.651]                 names <- names(envs)
[01:29:26.651]                 common <- intersect(names, old_names)
[01:29:26.651]                 added <- setdiff(names, old_names)
[01:29:26.651]                 removed <- setdiff(old_names, names)
[01:29:26.651]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:26.651]                   envs[common]]
[01:29:26.651]                 NAMES <- toupper(changed)
[01:29:26.651]                 args <- list()
[01:29:26.651]                 for (kk in seq_along(NAMES)) {
[01:29:26.651]                   name <- changed[[kk]]
[01:29:26.651]                   NAME <- NAMES[[kk]]
[01:29:26.651]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.651]                     next
[01:29:26.651]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.651]                 }
[01:29:26.651]                 NAMES <- toupper(added)
[01:29:26.651]                 for (kk in seq_along(NAMES)) {
[01:29:26.651]                   name <- added[[kk]]
[01:29:26.651]                   NAME <- NAMES[[kk]]
[01:29:26.651]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.651]                     next
[01:29:26.651]                   args[[name]] <- ""
[01:29:26.651]                 }
[01:29:26.651]                 NAMES <- toupper(removed)
[01:29:26.651]                 for (kk in seq_along(NAMES)) {
[01:29:26.651]                   name <- removed[[kk]]
[01:29:26.651]                   NAME <- NAMES[[kk]]
[01:29:26.651]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.651]                     next
[01:29:26.651]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.651]                 }
[01:29:26.651]                 if (length(args) > 0) 
[01:29:26.651]                   base::do.call(base::Sys.setenv, args = args)
[01:29:26.651]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:26.651]             }
[01:29:26.651]             else {
[01:29:26.651]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:26.651]             }
[01:29:26.651]             {
[01:29:26.651]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:26.651]                   0L) {
[01:29:26.651]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:26.651]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:26.651]                   base::options(opts)
[01:29:26.651]                 }
[01:29:26.651]                 {
[01:29:26.651]                   {
[01:29:26.651]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:26.651]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:26.651]                     -1344458670L), envir = base::globalenv(), 
[01:29:26.651]                       inherits = FALSE)
[01:29:26.651]                     NULL
[01:29:26.651]                   }
[01:29:26.651]                   options(future.plan = NULL)
[01:29:26.651]                   if (is.na(NA_character_)) 
[01:29:26.651]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.651]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:26.651]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:26.651]                   {
[01:29:26.651]                     future <- SequentialFuture(..., envir = envir)
[01:29:26.651]                     if (!future$lazy) 
[01:29:26.651]                       future <- run(future)
[01:29:26.651]                     invisible(future)
[01:29:26.651]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:26.651]                 }
[01:29:26.651]             }
[01:29:26.651]         }
[01:29:26.651]     })
[01:29:26.651]     if (TRUE) {
[01:29:26.651]         base::sink(type = "output", split = FALSE)
[01:29:26.651]         if (TRUE) {
[01:29:26.651]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:26.651]         }
[01:29:26.651]         else {
[01:29:26.651]             ...future.result["stdout"] <- base::list(NULL)
[01:29:26.651]         }
[01:29:26.651]         base::close(...future.stdout)
[01:29:26.651]         ...future.stdout <- NULL
[01:29:26.651]     }
[01:29:26.651]     ...future.result$conditions <- ...future.conditions
[01:29:26.651]     ...future.result$finished <- base::Sys.time()
[01:29:26.651]     ...future.result
[01:29:26.651] }
[01:29:26.655] assign_globals() ...
[01:29:26.655] List of 1
[01:29:26.655]  $ x: int [1:4] 0 1 2 3
[01:29:26.655]  - attr(*, "where")=List of 1
[01:29:26.655]   ..$ x:<environment: R_EmptyEnv> 
[01:29:26.655]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:26.655]  - attr(*, "resolved")= logi FALSE
[01:29:26.655]  - attr(*, "total_size")= num 64
[01:29:26.655]  - attr(*, "already-done")= logi TRUE
[01:29:26.659] - copied 'x' to environment
[01:29:26.659] assign_globals() ... done
[01:29:26.659] plan(): Setting new future strategy stack:
[01:29:26.659] List of future strategies:
[01:29:26.659] 1. sequential:
[01:29:26.659]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.659]    - tweaked: FALSE
[01:29:26.659]    - call: NULL
[01:29:26.660] plan(): nbrOfWorkers() = 1
[01:29:26.661] plan(): Setting new future strategy stack:
[01:29:26.661] List of future strategies:
[01:29:26.661] 1. sequential:
[01:29:26.661]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.661]    - tweaked: FALSE
[01:29:26.661]    - call: plan("sequential")
[01:29:26.662] plan(): nbrOfWorkers() = 1
[01:29:26.662] SequentialFuture started (and completed)
[01:29:26.663] - Launch lazy future ... done
[01:29:26.663] run() for 'SequentialFuture' ... done
[01:29:26.663] resolve() on list ...
[01:29:26.663]  recursive: 0
[01:29:26.664]  length: 4
[01:29:26.664] 
[01:29:26.664] resolved() for 'SequentialFuture' ...
[01:29:26.665] - state: 'finished'
[01:29:26.665] - run: TRUE
[01:29:26.665] - result: 'FutureResult'
[01:29:26.665] resolved() for 'SequentialFuture' ... done
[01:29:26.665] Future #1
[01:29:26.666] signalConditionsASAP(SequentialFuture, pos=1) ...
[01:29:26.666] - nx: 4
[01:29:26.666] - relay: TRUE
[01:29:26.666] - stdout: TRUE
[01:29:26.667] - signal: TRUE
[01:29:26.667] - resignal: FALSE
[01:29:26.667] - force: TRUE
[01:29:26.667] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:26.667] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:26.667]  - until=1
[01:29:26.668]  - relaying element #1
[01:29:26.668] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:26.668] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:26.668] signalConditionsASAP(SequentialFuture, pos=1) ... done
[01:29:26.669]  length: 3 (resolved future 1)
[01:29:26.669] resolved() for 'SequentialFuture' ...
[01:29:26.669] - state: 'finished'
[01:29:26.669] - run: TRUE
[01:29:26.669] - result: 'FutureResult'
[01:29:26.669] resolved() for 'SequentialFuture' ... done
[01:29:26.670] Future #2
[01:29:26.670] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:29:26.670] - nx: 4
[01:29:26.670] - relay: TRUE
[01:29:26.670] - stdout: TRUE
[01:29:26.671] - signal: TRUE
[01:29:26.671] - resignal: FALSE
[01:29:26.671] - force: TRUE
[01:29:26.671] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:26.671] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:26.671]  - until=2
[01:29:26.671]  - relaying element #2
[01:29:26.672] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:26.672] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:26.672] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:29:26.672]  length: 2 (resolved future 2)
[01:29:26.672] resolved() for 'SequentialFuture' ...
[01:29:26.673] - state: 'finished'
[01:29:26.673] - run: TRUE
[01:29:26.673] - result: 'FutureResult'
[01:29:26.673] resolved() for 'SequentialFuture' ... done
[01:29:26.673] Future #3
[01:29:26.674] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:29:26.674] - nx: 4
[01:29:26.674] - relay: TRUE
[01:29:26.674] - stdout: TRUE
[01:29:26.674] - signal: TRUE
[01:29:26.675] - resignal: FALSE
[01:29:26.675] - force: TRUE
[01:29:26.675] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:26.675] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:26.675]  - until=3
[01:29:26.675]  - relaying element #3
[01:29:26.676] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:26.676] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:26.676] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:29:26.676]  length: 1 (resolved future 3)
[01:29:26.676] resolved() for 'SequentialFuture' ...
[01:29:26.677] - state: 'finished'
[01:29:26.677] - run: TRUE
[01:29:26.677] - result: 'FutureResult'
[01:29:26.677] resolved() for 'SequentialFuture' ... done
[01:29:26.677] Future #4
[01:29:26.678] signalConditionsASAP(SequentialFuture, pos=4) ...
[01:29:26.678] - nx: 4
[01:29:26.678] - relay: TRUE
[01:29:26.678] - stdout: TRUE
[01:29:26.678] - signal: TRUE
[01:29:26.679] - resignal: FALSE
[01:29:26.680] - force: TRUE
[01:29:26.680] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:26.680] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:26.680]  - until=4
[01:29:26.681]  - relaying element #4
[01:29:26.681] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:26.681] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:26.681] signalConditionsASAP(SequentialFuture, pos=4) ... done
[01:29:26.681]  length: 0 (resolved future 4)
[01:29:26.682] Relaying remaining futures
[01:29:26.682] signalConditionsASAP(NULL, pos=0) ...
[01:29:26.682] - nx: 4
[01:29:26.682] - relay: TRUE
[01:29:26.682] - stdout: TRUE
[01:29:26.682] - signal: TRUE
[01:29:26.683] - resignal: FALSE
[01:29:26.683] - force: TRUE
[01:29:26.683] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:26.683] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[01:29:26.683] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:26.683] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:26.684] signalConditionsASAP(NULL, pos=0) ... done
[01:29:26.684] resolve() on list ... DONE
> 
> ## Assert that random seed is reset
> stopifnot(
+   identical(.GlobalEnv$.Random.seed, seed0),
+   identical(RNGkind(), okind)
+ )
> 
> 
> for (cores in 1:availCores) {
+   ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
+   if (!fullTest && isWin32) next
+   
+   message(sprintf("Testing with %d cores ...", cores))
+   options(mc.cores = cores)
+ 
+   for (strategy in supportedStrategies(cores)) {
+     message(sprintf("%s ...", strategy))
+ 
+     plan(strategy)
+ 
+     for (what in c("future", "%<-%")) {
+       .GlobalEnv$.Random.seed <- seed0
+ 
+       ## Fixed random seed
+       y1 <- fsample(0:3, seed = 42L, what = what)
+       print(y1)
+       stopifnot(identical(y1, y0))
+   
+       ## Assert that random seed is reset
+       stopifnot(
+         identical(.GlobalEnv$.Random.seed, seed0),
+         identical(RNGkind(), okind)
+       )
+   
+       ## Fixed random seed
+       y2 <- fsample(0:3, seed = 42L, what = what)
+       print(y2)
+       stopifnot(identical(y2, y1))
+       stopifnot(identical(y2, y0))
+   
+       ## Assert that random seed is reset
+       stopifnot(
+         identical(.GlobalEnv$.Random.seed, seed0),
+         identical(RNGkind(), okind)
+       )
+   
+       ## No seed
+       for (misuse in c("ignore", "warning", "error")) {
+         options(future.rng.onMisuse = misuse)
+ 
+         y3 <- tryCatch({
+ 	  ## WORKAROUND: fsample() triggers a R_FUTURE_GLOBALS_ONREFERENCE
+ 	  ##             warning.  Not sure why. /HB 2019-12-27
+ 	  ovalue <- Sys.getenv("R_FUTURE_GLOBALS_ONREFERENCE")
+ 	  on.exit(Sys.setenv("R_FUTURE_GLOBALS_ONREFERENCE" = ovalue))
+ 	  Sys.setenv("R_FUTURE_GLOBALS_ONREFERENCE" = "ignore")
+ 	  
+           fsample(0:3, what = what, seed = FALSE)
+         }, warning = identity, error = identity)
+         print(y3)
+         if (misuse %in% c("warning", "error")) {
+           stopifnot(
+             inherits(y3, misuse),
+             inherits(y3, "RngFutureCondition"),
+             inherits(y3, switch(misuse,
+               warning = "RngFutureWarning",
+               error   = "RngFutureError"
+             ))
+           )
+         }
+ 
+         ## seed = NULL equals seed = FALSE but without the check of misuse
+         y4 <- fsample(0:3, what = what, seed = NULL)
+         print(y4)
+       }
+       
+       options(future.rng.onMisuse = "ignore")
+     }
+ 
+     message(sprintf("%s ... done", strategy))
+   }
+ 
+   message(sprintf("Testing with %d cores ... DONE", cores))
+ } ## for (cores ...)
Testing with 1 cores ...
sequential ...
[01:29:26.719] plan(): Setting new future strategy stack:
[01:29:26.719] List of future strategies:
[01:29:26.719] 1. sequential:
[01:29:26.719]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.719]    - tweaked: FALSE
[01:29:26.719]    - call: plan(strategy)
[01:29:26.720] plan(): nbrOfWorkers() = 1
[01:29:26.720] getGlobalsAndPackages() ...
[01:29:26.720] Searching for globals...
[01:29:26.724] - globals found: [3] '{', 'sample', 'x'
[01:29:26.725] Searching for globals ... DONE
[01:29:26.725] Resolving globals: FALSE
[01:29:26.727] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:26.728] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:26.728] - globals: [1] 'x'
[01:29:26.729] 
[01:29:26.729] getGlobalsAndPackages() ... DONE
[01:29:26.730] run() for 'Future' ...
[01:29:26.730] - state: 'created'
[01:29:26.731] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:26.732] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:26.732] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:26.733]   - Field: 'label'
[01:29:26.733]   - Field: 'local'
[01:29:26.734]   - Field: 'owner'
[01:29:26.734]   - Field: 'envir'
[01:29:26.734]   - Field: 'packages'
[01:29:26.735]   - Field: 'gc'
[01:29:26.735]   - Field: 'conditions'
[01:29:26.736]   - Field: 'expr'
[01:29:26.736]   - Field: 'uuid'
[01:29:26.736]   - Field: 'seed'
[01:29:26.737]   - Field: 'version'
[01:29:26.737]   - Field: 'result'
[01:29:26.738]   - Field: 'asynchronous'
[01:29:26.738]   - Field: 'calls'
[01:29:26.738]   - Field: 'globals'
[01:29:26.739]   - Field: 'stdout'
[01:29:26.739]   - Field: 'earlySignal'
[01:29:26.739]   - Field: 'lazy'
[01:29:26.740]   - Field: 'state'
[01:29:26.740] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:26.741] - Launch lazy future ...
[01:29:26.741] Packages needed by the future expression (n = 0): <none>
[01:29:26.742] Packages needed by future strategies (n = 0): <none>
[01:29:26.743] {
[01:29:26.743]     {
[01:29:26.743]         {
[01:29:26.743]             ...future.startTime <- base::Sys.time()
[01:29:26.743]             {
[01:29:26.743]                 {
[01:29:26.743]                   {
[01:29:26.743]                     {
[01:29:26.743]                       base::local({
[01:29:26.743]                         has_future <- base::requireNamespace("future", 
[01:29:26.743]                           quietly = TRUE)
[01:29:26.743]                         if (has_future) {
[01:29:26.743]                           ns <- base::getNamespace("future")
[01:29:26.743]                           version <- ns[[".package"]][["version"]]
[01:29:26.743]                           if (is.null(version)) 
[01:29:26.743]                             version <- utils::packageVersion("future")
[01:29:26.743]                         }
[01:29:26.743]                         else {
[01:29:26.743]                           version <- NULL
[01:29:26.743]                         }
[01:29:26.743]                         if (!has_future || version < "1.8.0") {
[01:29:26.743]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:26.743]                             "", base::R.version$version.string), 
[01:29:26.743]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:26.743]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:26.743]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:26.743]                               "release", "version")], collapse = " "), 
[01:29:26.743]                             hostname = base::Sys.info()[["nodename"]])
[01:29:26.743]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:26.743]                             info)
[01:29:26.743]                           info <- base::paste(info, collapse = "; ")
[01:29:26.743]                           if (!has_future) {
[01:29:26.743]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:26.743]                               info)
[01:29:26.743]                           }
[01:29:26.743]                           else {
[01:29:26.743]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:26.743]                               info, version)
[01:29:26.743]                           }
[01:29:26.743]                           base::stop(msg)
[01:29:26.743]                         }
[01:29:26.743]                       })
[01:29:26.743]                     }
[01:29:26.743]                     options(future.plan = NULL)
[01:29:26.743]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.743]                     future::plan("default", .cleanup = FALSE, 
[01:29:26.743]                       .init = FALSE)
[01:29:26.743]                   }
[01:29:26.743]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[01:29:26.743]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[01:29:26.743]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[01:29:26.743]                 }
[01:29:26.743]                 ...future.workdir <- getwd()
[01:29:26.743]             }
[01:29:26.743]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:26.743]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:26.743]         }
[01:29:26.743]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:26.743]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:26.743]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:26.743]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:26.743]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:26.743]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:26.743]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:26.743]             base::names(...future.oldOptions))
[01:29:26.743]     }
[01:29:26.743]     if (FALSE) {
[01:29:26.743]     }
[01:29:26.743]     else {
[01:29:26.743]         if (TRUE) {
[01:29:26.743]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:26.743]                 open = "w")
[01:29:26.743]         }
[01:29:26.743]         else {
[01:29:26.743]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:26.743]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:26.743]         }
[01:29:26.743]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:26.743]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:26.743]             base::sink(type = "output", split = FALSE)
[01:29:26.743]             base::close(...future.stdout)
[01:29:26.743]         }, add = TRUE)
[01:29:26.743]     }
[01:29:26.743]     ...future.frame <- base::sys.nframe()
[01:29:26.743]     ...future.conditions <- base::list()
[01:29:26.743]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:26.743]     if (FALSE) {
[01:29:26.743]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:26.743]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:26.743]     }
[01:29:26.743]     ...future.result <- base::tryCatch({
[01:29:26.743]         base::withCallingHandlers({
[01:29:26.743]             ...future.value <- base::withVisible(base::local({
[01:29:26.743]                 sample(x, size = 1L)
[01:29:26.743]             }))
[01:29:26.743]             future::FutureResult(value = ...future.value$value, 
[01:29:26.743]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.743]                   ...future.rng), globalenv = if (FALSE) 
[01:29:26.743]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:26.743]                     ...future.globalenv.names))
[01:29:26.743]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:26.743]         }, condition = base::local({
[01:29:26.743]             c <- base::c
[01:29:26.743]             inherits <- base::inherits
[01:29:26.743]             invokeRestart <- base::invokeRestart
[01:29:26.743]             length <- base::length
[01:29:26.743]             list <- base::list
[01:29:26.743]             seq.int <- base::seq.int
[01:29:26.743]             signalCondition <- base::signalCondition
[01:29:26.743]             sys.calls <- base::sys.calls
[01:29:26.743]             `[[` <- base::`[[`
[01:29:26.743]             `+` <- base::`+`
[01:29:26.743]             `<<-` <- base::`<<-`
[01:29:26.743]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:26.743]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:26.743]                   3L)]
[01:29:26.743]             }
[01:29:26.743]             function(cond) {
[01:29:26.743]                 is_error <- inherits(cond, "error")
[01:29:26.743]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:26.743]                   NULL)
[01:29:26.743]                 if (is_error) {
[01:29:26.743]                   sessionInformation <- function() {
[01:29:26.743]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:26.743]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:26.743]                       search = base::search(), system = base::Sys.info())
[01:29:26.743]                   }
[01:29:26.743]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.743]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:26.743]                     cond$call), session = sessionInformation(), 
[01:29:26.743]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:26.743]                   signalCondition(cond)
[01:29:26.743]                 }
[01:29:26.743]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:26.743]                 "immediateCondition"))) {
[01:29:26.743]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:26.743]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.743]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:26.743]                   if (TRUE && !signal) {
[01:29:26.743]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.743]                     {
[01:29:26.743]                       inherits <- base::inherits
[01:29:26.743]                       invokeRestart <- base::invokeRestart
[01:29:26.743]                       is.null <- base::is.null
[01:29:26.743]                       muffled <- FALSE
[01:29:26.743]                       if (inherits(cond, "message")) {
[01:29:26.743]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.743]                         if (muffled) 
[01:29:26.743]                           invokeRestart("muffleMessage")
[01:29:26.743]                       }
[01:29:26.743]                       else if (inherits(cond, "warning")) {
[01:29:26.743]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.743]                         if (muffled) 
[01:29:26.743]                           invokeRestart("muffleWarning")
[01:29:26.743]                       }
[01:29:26.743]                       else if (inherits(cond, "condition")) {
[01:29:26.743]                         if (!is.null(pattern)) {
[01:29:26.743]                           computeRestarts <- base::computeRestarts
[01:29:26.743]                           grepl <- base::grepl
[01:29:26.743]                           restarts <- computeRestarts(cond)
[01:29:26.743]                           for (restart in restarts) {
[01:29:26.743]                             name <- restart$name
[01:29:26.743]                             if (is.null(name)) 
[01:29:26.743]                               next
[01:29:26.743]                             if (!grepl(pattern, name)) 
[01:29:26.743]                               next
[01:29:26.743]                             invokeRestart(restart)
[01:29:26.743]                             muffled <- TRUE
[01:29:26.743]                             break
[01:29:26.743]                           }
[01:29:26.743]                         }
[01:29:26.743]                       }
[01:29:26.743]                       invisible(muffled)
[01:29:26.743]                     }
[01:29:26.743]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.743]                   }
[01:29:26.743]                 }
[01:29:26.743]                 else {
[01:29:26.743]                   if (TRUE) {
[01:29:26.743]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.743]                     {
[01:29:26.743]                       inherits <- base::inherits
[01:29:26.743]                       invokeRestart <- base::invokeRestart
[01:29:26.743]                       is.null <- base::is.null
[01:29:26.743]                       muffled <- FALSE
[01:29:26.743]                       if (inherits(cond, "message")) {
[01:29:26.743]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.743]                         if (muffled) 
[01:29:26.743]                           invokeRestart("muffleMessage")
[01:29:26.743]                       }
[01:29:26.743]                       else if (inherits(cond, "warning")) {
[01:29:26.743]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.743]                         if (muffled) 
[01:29:26.743]                           invokeRestart("muffleWarning")
[01:29:26.743]                       }
[01:29:26.743]                       else if (inherits(cond, "condition")) {
[01:29:26.743]                         if (!is.null(pattern)) {
[01:29:26.743]                           computeRestarts <- base::computeRestarts
[01:29:26.743]                           grepl <- base::grepl
[01:29:26.743]                           restarts <- computeRestarts(cond)
[01:29:26.743]                           for (restart in restarts) {
[01:29:26.743]                             name <- restart$name
[01:29:26.743]                             if (is.null(name)) 
[01:29:26.743]                               next
[01:29:26.743]                             if (!grepl(pattern, name)) 
[01:29:26.743]                               next
[01:29:26.743]                             invokeRestart(restart)
[01:29:26.743]                             muffled <- TRUE
[01:29:26.743]                             break
[01:29:26.743]                           }
[01:29:26.743]                         }
[01:29:26.743]                       }
[01:29:26.743]                       invisible(muffled)
[01:29:26.743]                     }
[01:29:26.743]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.743]                   }
[01:29:26.743]                 }
[01:29:26.743]             }
[01:29:26.743]         }))
[01:29:26.743]     }, error = function(ex) {
[01:29:26.743]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:26.743]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.743]                 ...future.rng), started = ...future.startTime, 
[01:29:26.743]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:26.743]             version = "1.8"), class = "FutureResult")
[01:29:26.743]     }, finally = {
[01:29:26.743]         if (!identical(...future.workdir, getwd())) 
[01:29:26.743]             setwd(...future.workdir)
[01:29:26.743]         {
[01:29:26.743]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:26.743]                 ...future.oldOptions$nwarnings <- NULL
[01:29:26.743]             }
[01:29:26.743]             base::options(...future.oldOptions)
[01:29:26.743]             if (.Platform$OS.type == "windows") {
[01:29:26.743]                 old_names <- names(...future.oldEnvVars)
[01:29:26.743]                 envs <- base::Sys.getenv()
[01:29:26.743]                 names <- names(envs)
[01:29:26.743]                 common <- intersect(names, old_names)
[01:29:26.743]                 added <- setdiff(names, old_names)
[01:29:26.743]                 removed <- setdiff(old_names, names)
[01:29:26.743]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:26.743]                   envs[common]]
[01:29:26.743]                 NAMES <- toupper(changed)
[01:29:26.743]                 args <- list()
[01:29:26.743]                 for (kk in seq_along(NAMES)) {
[01:29:26.743]                   name <- changed[[kk]]
[01:29:26.743]                   NAME <- NAMES[[kk]]
[01:29:26.743]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.743]                     next
[01:29:26.743]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.743]                 }
[01:29:26.743]                 NAMES <- toupper(added)
[01:29:26.743]                 for (kk in seq_along(NAMES)) {
[01:29:26.743]                   name <- added[[kk]]
[01:29:26.743]                   NAME <- NAMES[[kk]]
[01:29:26.743]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.743]                     next
[01:29:26.743]                   args[[name]] <- ""
[01:29:26.743]                 }
[01:29:26.743]                 NAMES <- toupper(removed)
[01:29:26.743]                 for (kk in seq_along(NAMES)) {
[01:29:26.743]                   name <- removed[[kk]]
[01:29:26.743]                   NAME <- NAMES[[kk]]
[01:29:26.743]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.743]                     next
[01:29:26.743]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.743]                 }
[01:29:26.743]                 if (length(args) > 0) 
[01:29:26.743]                   base::do.call(base::Sys.setenv, args = args)
[01:29:26.743]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:26.743]             }
[01:29:26.743]             else {
[01:29:26.743]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:26.743]             }
[01:29:26.743]             {
[01:29:26.743]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:26.743]                   0L) {
[01:29:26.743]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:26.743]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:26.743]                   base::options(opts)
[01:29:26.743]                 }
[01:29:26.743]                 {
[01:29:26.743]                   {
[01:29:26.743]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:26.743]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:26.743]                     -1344458670L), envir = base::globalenv(), 
[01:29:26.743]                       inherits = FALSE)
[01:29:26.743]                     NULL
[01:29:26.743]                   }
[01:29:26.743]                   options(future.plan = NULL)
[01:29:26.743]                   if (is.na(NA_character_)) 
[01:29:26.743]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.743]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:26.743]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:26.743]                   {
[01:29:26.743]                     future <- SequentialFuture(..., envir = envir)
[01:29:26.743]                     if (!future$lazy) 
[01:29:26.743]                       future <- run(future)
[01:29:26.743]                     invisible(future)
[01:29:26.743]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:26.743]                 }
[01:29:26.743]             }
[01:29:26.743]         }
[01:29:26.743]     })
[01:29:26.743]     if (TRUE) {
[01:29:26.743]         base::sink(type = "output", split = FALSE)
[01:29:26.743]         if (TRUE) {
[01:29:26.743]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:26.743]         }
[01:29:26.743]         else {
[01:29:26.743]             ...future.result["stdout"] <- base::list(NULL)
[01:29:26.743]         }
[01:29:26.743]         base::close(...future.stdout)
[01:29:26.743]         ...future.stdout <- NULL
[01:29:26.743]     }
[01:29:26.743]     ...future.result$conditions <- ...future.conditions
[01:29:26.743]     ...future.result$finished <- base::Sys.time()
[01:29:26.743]     ...future.result
[01:29:26.743] }
[01:29:26.748] assign_globals() ...
[01:29:26.748] List of 1
[01:29:26.748]  $ x: int [1:4] 0 1 2 3
[01:29:26.748]  - attr(*, "where")=List of 1
[01:29:26.748]   ..$ x:<environment: R_EmptyEnv> 
[01:29:26.748]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:26.748]  - attr(*, "resolved")= logi FALSE
[01:29:26.748]  - attr(*, "total_size")= num 64
[01:29:26.748]  - attr(*, "already-done")= logi TRUE
[01:29:26.757] - copied 'x' to environment
[01:29:26.757] assign_globals() ... done
[01:29:26.758] plan(): Setting new future strategy stack:
[01:29:26.758] List of future strategies:
[01:29:26.758] 1. sequential:
[01:29:26.758]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.758]    - tweaked: FALSE
[01:29:26.758]    - call: NULL
[01:29:26.759] plan(): nbrOfWorkers() = 1
[01:29:26.761] plan(): Setting new future strategy stack:
[01:29:26.761] List of future strategies:
[01:29:26.761] 1. sequential:
[01:29:26.761]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.761]    - tweaked: FALSE
[01:29:26.761]    - call: plan(strategy)
[01:29:26.762] plan(): nbrOfWorkers() = 1
[01:29:26.762] SequentialFuture started (and completed)
[01:29:26.762] - Launch lazy future ... done
[01:29:26.763] run() for 'SequentialFuture' ... done
[01:29:26.763] getGlobalsAndPackages() ...
[01:29:26.763] Searching for globals...
[01:29:26.766] - globals found: [3] '{', 'sample', 'x'
[01:29:26.766] Searching for globals ... DONE
[01:29:26.766] Resolving globals: FALSE
[01:29:26.767] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:26.768] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:26.768] - globals: [1] 'x'
[01:29:26.768] 
[01:29:26.768] getGlobalsAndPackages() ... DONE
[01:29:26.769] run() for 'Future' ...
[01:29:26.769] - state: 'created'
[01:29:26.769] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:26.770] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:26.770] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:26.770]   - Field: 'label'
[01:29:26.770]   - Field: 'local'
[01:29:26.771]   - Field: 'owner'
[01:29:26.771]   - Field: 'envir'
[01:29:26.771]   - Field: 'packages'
[01:29:26.771]   - Field: 'gc'
[01:29:26.771]   - Field: 'conditions'
[01:29:26.772]   - Field: 'expr'
[01:29:26.772]   - Field: 'uuid'
[01:29:26.772]   - Field: 'seed'
[01:29:26.772]   - Field: 'version'
[01:29:26.772]   - Field: 'result'
[01:29:26.773]   - Field: 'asynchronous'
[01:29:26.773]   - Field: 'calls'
[01:29:26.773]   - Field: 'globals'
[01:29:26.773]   - Field: 'stdout'
[01:29:26.773]   - Field: 'earlySignal'
[01:29:26.773]   - Field: 'lazy'
[01:29:26.774]   - Field: 'state'
[01:29:26.774] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:26.774] - Launch lazy future ...
[01:29:26.774] Packages needed by the future expression (n = 0): <none>
[01:29:26.775] Packages needed by future strategies (n = 0): <none>
[01:29:26.775] {
[01:29:26.775]     {
[01:29:26.775]         {
[01:29:26.775]             ...future.startTime <- base::Sys.time()
[01:29:26.775]             {
[01:29:26.775]                 {
[01:29:26.775]                   {
[01:29:26.775]                     {
[01:29:26.775]                       base::local({
[01:29:26.775]                         has_future <- base::requireNamespace("future", 
[01:29:26.775]                           quietly = TRUE)
[01:29:26.775]                         if (has_future) {
[01:29:26.775]                           ns <- base::getNamespace("future")
[01:29:26.775]                           version <- ns[[".package"]][["version"]]
[01:29:26.775]                           if (is.null(version)) 
[01:29:26.775]                             version <- utils::packageVersion("future")
[01:29:26.775]                         }
[01:29:26.775]                         else {
[01:29:26.775]                           version <- NULL
[01:29:26.775]                         }
[01:29:26.775]                         if (!has_future || version < "1.8.0") {
[01:29:26.775]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:26.775]                             "", base::R.version$version.string), 
[01:29:26.775]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:26.775]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:26.775]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:26.775]                               "release", "version")], collapse = " "), 
[01:29:26.775]                             hostname = base::Sys.info()[["nodename"]])
[01:29:26.775]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:26.775]                             info)
[01:29:26.775]                           info <- base::paste(info, collapse = "; ")
[01:29:26.775]                           if (!has_future) {
[01:29:26.775]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:26.775]                               info)
[01:29:26.775]                           }
[01:29:26.775]                           else {
[01:29:26.775]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:26.775]                               info, version)
[01:29:26.775]                           }
[01:29:26.775]                           base::stop(msg)
[01:29:26.775]                         }
[01:29:26.775]                       })
[01:29:26.775]                     }
[01:29:26.775]                     options(future.plan = NULL)
[01:29:26.775]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.775]                     future::plan("default", .cleanup = FALSE, 
[01:29:26.775]                       .init = FALSE)
[01:29:26.775]                   }
[01:29:26.775]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[01:29:26.775]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[01:29:26.775]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[01:29:26.775]                 }
[01:29:26.775]                 ...future.workdir <- getwd()
[01:29:26.775]             }
[01:29:26.775]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:26.775]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:26.775]         }
[01:29:26.775]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:26.775]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:26.775]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:26.775]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:26.775]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:26.775]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:26.775]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:26.775]             base::names(...future.oldOptions))
[01:29:26.775]     }
[01:29:26.775]     if (FALSE) {
[01:29:26.775]     }
[01:29:26.775]     else {
[01:29:26.775]         if (TRUE) {
[01:29:26.775]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:26.775]                 open = "w")
[01:29:26.775]         }
[01:29:26.775]         else {
[01:29:26.775]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:26.775]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:26.775]         }
[01:29:26.775]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:26.775]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:26.775]             base::sink(type = "output", split = FALSE)
[01:29:26.775]             base::close(...future.stdout)
[01:29:26.775]         }, add = TRUE)
[01:29:26.775]     }
[01:29:26.775]     ...future.frame <- base::sys.nframe()
[01:29:26.775]     ...future.conditions <- base::list()
[01:29:26.775]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:26.775]     if (FALSE) {
[01:29:26.775]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:26.775]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:26.775]     }
[01:29:26.775]     ...future.result <- base::tryCatch({
[01:29:26.775]         base::withCallingHandlers({
[01:29:26.775]             ...future.value <- base::withVisible(base::local({
[01:29:26.775]                 sample(x, size = 1L)
[01:29:26.775]             }))
[01:29:26.775]             future::FutureResult(value = ...future.value$value, 
[01:29:26.775]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.775]                   ...future.rng), globalenv = if (FALSE) 
[01:29:26.775]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:26.775]                     ...future.globalenv.names))
[01:29:26.775]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:26.775]         }, condition = base::local({
[01:29:26.775]             c <- base::c
[01:29:26.775]             inherits <- base::inherits
[01:29:26.775]             invokeRestart <- base::invokeRestart
[01:29:26.775]             length <- base::length
[01:29:26.775]             list <- base::list
[01:29:26.775]             seq.int <- base::seq.int
[01:29:26.775]             signalCondition <- base::signalCondition
[01:29:26.775]             sys.calls <- base::sys.calls
[01:29:26.775]             `[[` <- base::`[[`
[01:29:26.775]             `+` <- base::`+`
[01:29:26.775]             `<<-` <- base::`<<-`
[01:29:26.775]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:26.775]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:26.775]                   3L)]
[01:29:26.775]             }
[01:29:26.775]             function(cond) {
[01:29:26.775]                 is_error <- inherits(cond, "error")
[01:29:26.775]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:26.775]                   NULL)
[01:29:26.775]                 if (is_error) {
[01:29:26.775]                   sessionInformation <- function() {
[01:29:26.775]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:26.775]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:26.775]                       search = base::search(), system = base::Sys.info())
[01:29:26.775]                   }
[01:29:26.775]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.775]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:26.775]                     cond$call), session = sessionInformation(), 
[01:29:26.775]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:26.775]                   signalCondition(cond)
[01:29:26.775]                 }
[01:29:26.775]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:26.775]                 "immediateCondition"))) {
[01:29:26.775]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:26.775]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.775]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:26.775]                   if (TRUE && !signal) {
[01:29:26.775]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.775]                     {
[01:29:26.775]                       inherits <- base::inherits
[01:29:26.775]                       invokeRestart <- base::invokeRestart
[01:29:26.775]                       is.null <- base::is.null
[01:29:26.775]                       muffled <- FALSE
[01:29:26.775]                       if (inherits(cond, "message")) {
[01:29:26.775]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.775]                         if (muffled) 
[01:29:26.775]                           invokeRestart("muffleMessage")
[01:29:26.775]                       }
[01:29:26.775]                       else if (inherits(cond, "warning")) {
[01:29:26.775]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.775]                         if (muffled) 
[01:29:26.775]                           invokeRestart("muffleWarning")
[01:29:26.775]                       }
[01:29:26.775]                       else if (inherits(cond, "condition")) {
[01:29:26.775]                         if (!is.null(pattern)) {
[01:29:26.775]                           computeRestarts <- base::computeRestarts
[01:29:26.775]                           grepl <- base::grepl
[01:29:26.775]                           restarts <- computeRestarts(cond)
[01:29:26.775]                           for (restart in restarts) {
[01:29:26.775]                             name <- restart$name
[01:29:26.775]                             if (is.null(name)) 
[01:29:26.775]                               next
[01:29:26.775]                             if (!grepl(pattern, name)) 
[01:29:26.775]                               next
[01:29:26.775]                             invokeRestart(restart)
[01:29:26.775]                             muffled <- TRUE
[01:29:26.775]                             break
[01:29:26.775]                           }
[01:29:26.775]                         }
[01:29:26.775]                       }
[01:29:26.775]                       invisible(muffled)
[01:29:26.775]                     }
[01:29:26.775]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.775]                   }
[01:29:26.775]                 }
[01:29:26.775]                 else {
[01:29:26.775]                   if (TRUE) {
[01:29:26.775]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.775]                     {
[01:29:26.775]                       inherits <- base::inherits
[01:29:26.775]                       invokeRestart <- base::invokeRestart
[01:29:26.775]                       is.null <- base::is.null
[01:29:26.775]                       muffled <- FALSE
[01:29:26.775]                       if (inherits(cond, "message")) {
[01:29:26.775]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.775]                         if (muffled) 
[01:29:26.775]                           invokeRestart("muffleMessage")
[01:29:26.775]                       }
[01:29:26.775]                       else if (inherits(cond, "warning")) {
[01:29:26.775]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.775]                         if (muffled) 
[01:29:26.775]                           invokeRestart("muffleWarning")
[01:29:26.775]                       }
[01:29:26.775]                       else if (inherits(cond, "condition")) {
[01:29:26.775]                         if (!is.null(pattern)) {
[01:29:26.775]                           computeRestarts <- base::computeRestarts
[01:29:26.775]                           grepl <- base::grepl
[01:29:26.775]                           restarts <- computeRestarts(cond)
[01:29:26.775]                           for (restart in restarts) {
[01:29:26.775]                             name <- restart$name
[01:29:26.775]                             if (is.null(name)) 
[01:29:26.775]                               next
[01:29:26.775]                             if (!grepl(pattern, name)) 
[01:29:26.775]                               next
[01:29:26.775]                             invokeRestart(restart)
[01:29:26.775]                             muffled <- TRUE
[01:29:26.775]                             break
[01:29:26.775]                           }
[01:29:26.775]                         }
[01:29:26.775]                       }
[01:29:26.775]                       invisible(muffled)
[01:29:26.775]                     }
[01:29:26.775]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.775]                   }
[01:29:26.775]                 }
[01:29:26.775]             }
[01:29:26.775]         }))
[01:29:26.775]     }, error = function(ex) {
[01:29:26.775]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:26.775]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.775]                 ...future.rng), started = ...future.startTime, 
[01:29:26.775]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:26.775]             version = "1.8"), class = "FutureResult")
[01:29:26.775]     }, finally = {
[01:29:26.775]         if (!identical(...future.workdir, getwd())) 
[01:29:26.775]             setwd(...future.workdir)
[01:29:26.775]         {
[01:29:26.775]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:26.775]                 ...future.oldOptions$nwarnings <- NULL
[01:29:26.775]             }
[01:29:26.775]             base::options(...future.oldOptions)
[01:29:26.775]             if (.Platform$OS.type == "windows") {
[01:29:26.775]                 old_names <- names(...future.oldEnvVars)
[01:29:26.775]                 envs <- base::Sys.getenv()
[01:29:26.775]                 names <- names(envs)
[01:29:26.775]                 common <- intersect(names, old_names)
[01:29:26.775]                 added <- setdiff(names, old_names)
[01:29:26.775]                 removed <- setdiff(old_names, names)
[01:29:26.775]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:26.775]                   envs[common]]
[01:29:26.775]                 NAMES <- toupper(changed)
[01:29:26.775]                 args <- list()
[01:29:26.775]                 for (kk in seq_along(NAMES)) {
[01:29:26.775]                   name <- changed[[kk]]
[01:29:26.775]                   NAME <- NAMES[[kk]]
[01:29:26.775]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.775]                     next
[01:29:26.775]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.775]                 }
[01:29:26.775]                 NAMES <- toupper(added)
[01:29:26.775]                 for (kk in seq_along(NAMES)) {
[01:29:26.775]                   name <- added[[kk]]
[01:29:26.775]                   NAME <- NAMES[[kk]]
[01:29:26.775]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.775]                     next
[01:29:26.775]                   args[[name]] <- ""
[01:29:26.775]                 }
[01:29:26.775]                 NAMES <- toupper(removed)
[01:29:26.775]                 for (kk in seq_along(NAMES)) {
[01:29:26.775]                   name <- removed[[kk]]
[01:29:26.775]                   NAME <- NAMES[[kk]]
[01:29:26.775]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.775]                     next
[01:29:26.775]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.775]                 }
[01:29:26.775]                 if (length(args) > 0) 
[01:29:26.775]                   base::do.call(base::Sys.setenv, args = args)
[01:29:26.775]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:26.775]             }
[01:29:26.775]             else {
[01:29:26.775]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:26.775]             }
[01:29:26.775]             {
[01:29:26.775]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:26.775]                   0L) {
[01:29:26.775]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:26.775]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:26.775]                   base::options(opts)
[01:29:26.775]                 }
[01:29:26.775]                 {
[01:29:26.775]                   {
[01:29:26.775]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:26.775]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:26.775]                     -1344458670L), envir = base::globalenv(), 
[01:29:26.775]                       inherits = FALSE)
[01:29:26.775]                     NULL
[01:29:26.775]                   }
[01:29:26.775]                   options(future.plan = NULL)
[01:29:26.775]                   if (is.na(NA_character_)) 
[01:29:26.775]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.775]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:26.775]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:26.775]                   {
[01:29:26.775]                     future <- SequentialFuture(..., envir = envir)
[01:29:26.775]                     if (!future$lazy) 
[01:29:26.775]                       future <- run(future)
[01:29:26.775]                     invisible(future)
[01:29:26.775]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:26.775]                 }
[01:29:26.775]             }
[01:29:26.775]         }
[01:29:26.775]     })
[01:29:26.775]     if (TRUE) {
[01:29:26.775]         base::sink(type = "output", split = FALSE)
[01:29:26.775]         if (TRUE) {
[01:29:26.775]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:26.775]         }
[01:29:26.775]         else {
[01:29:26.775]             ...future.result["stdout"] <- base::list(NULL)
[01:29:26.775]         }
[01:29:26.775]         base::close(...future.stdout)
[01:29:26.775]         ...future.stdout <- NULL
[01:29:26.775]     }
[01:29:26.775]     ...future.result$conditions <- ...future.conditions
[01:29:26.775]     ...future.result$finished <- base::Sys.time()
[01:29:26.775]     ...future.result
[01:29:26.775] }
[01:29:26.779] assign_globals() ...
[01:29:26.780] List of 1
[01:29:26.780]  $ x: int [1:4] 0 1 2 3
[01:29:26.780]  - attr(*, "where")=List of 1
[01:29:26.780]   ..$ x:<environment: R_EmptyEnv> 
[01:29:26.780]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:26.780]  - attr(*, "resolved")= logi FALSE
[01:29:26.780]  - attr(*, "total_size")= num 64
[01:29:26.780]  - attr(*, "already-done")= logi TRUE
[01:29:26.783] - copied 'x' to environment
[01:29:26.783] assign_globals() ... done
[01:29:26.784] plan(): Setting new future strategy stack:
[01:29:26.784] List of future strategies:
[01:29:26.784] 1. sequential:
[01:29:26.784]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.784]    - tweaked: FALSE
[01:29:26.784]    - call: NULL
[01:29:26.785] plan(): nbrOfWorkers() = 1
[01:29:26.786] plan(): Setting new future strategy stack:
[01:29:26.786] List of future strategies:
[01:29:26.786] 1. sequential:
[01:29:26.786]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.786]    - tweaked: FALSE
[01:29:26.786]    - call: plan(strategy)
[01:29:26.787] plan(): nbrOfWorkers() = 1
[01:29:26.788] SequentialFuture started (and completed)
[01:29:26.788] - Launch lazy future ... done
[01:29:26.788] run() for 'SequentialFuture' ... done
[01:29:26.788] getGlobalsAndPackages() ...
[01:29:26.789] Searching for globals...
[01:29:26.790] - globals found: [3] '{', 'sample', 'x'
[01:29:26.790] Searching for globals ... DONE
[01:29:26.791] Resolving globals: FALSE
[01:29:26.791] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:26.792] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:26.792] - globals: [1] 'x'
[01:29:26.792] 
[01:29:26.792] getGlobalsAndPackages() ... DONE
[01:29:26.793] run() for 'Future' ...
[01:29:26.793] - state: 'created'
[01:29:26.793] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:26.794] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:26.794] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:26.796]   - Field: 'label'
[01:29:26.796]   - Field: 'local'
[01:29:26.796]   - Field: 'owner'
[01:29:26.797]   - Field: 'envir'
[01:29:26.797]   - Field: 'packages'
[01:29:26.797]   - Field: 'gc'
[01:29:26.797]   - Field: 'conditions'
[01:29:26.797]   - Field: 'expr'
[01:29:26.798]   - Field: 'uuid'
[01:29:26.798]   - Field: 'seed'
[01:29:26.798]   - Field: 'version'
[01:29:26.798]   - Field: 'result'
[01:29:26.798]   - Field: 'asynchronous'
[01:29:26.799]   - Field: 'calls'
[01:29:26.799]   - Field: 'globals'
[01:29:26.799]   - Field: 'stdout'
[01:29:26.799]   - Field: 'earlySignal'
[01:29:26.800]   - Field: 'lazy'
[01:29:26.800]   - Field: 'state'
[01:29:26.800] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:26.800] - Launch lazy future ...
[01:29:26.800] Packages needed by the future expression (n = 0): <none>
[01:29:26.801] Packages needed by future strategies (n = 0): <none>
[01:29:26.801] {
[01:29:26.801]     {
[01:29:26.801]         {
[01:29:26.801]             ...future.startTime <- base::Sys.time()
[01:29:26.801]             {
[01:29:26.801]                 {
[01:29:26.801]                   {
[01:29:26.801]                     {
[01:29:26.801]                       base::local({
[01:29:26.801]                         has_future <- base::requireNamespace("future", 
[01:29:26.801]                           quietly = TRUE)
[01:29:26.801]                         if (has_future) {
[01:29:26.801]                           ns <- base::getNamespace("future")
[01:29:26.801]                           version <- ns[[".package"]][["version"]]
[01:29:26.801]                           if (is.null(version)) 
[01:29:26.801]                             version <- utils::packageVersion("future")
[01:29:26.801]                         }
[01:29:26.801]                         else {
[01:29:26.801]                           version <- NULL
[01:29:26.801]                         }
[01:29:26.801]                         if (!has_future || version < "1.8.0") {
[01:29:26.801]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:26.801]                             "", base::R.version$version.string), 
[01:29:26.801]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:26.801]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:26.801]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:26.801]                               "release", "version")], collapse = " "), 
[01:29:26.801]                             hostname = base::Sys.info()[["nodename"]])
[01:29:26.801]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:26.801]                             info)
[01:29:26.801]                           info <- base::paste(info, collapse = "; ")
[01:29:26.801]                           if (!has_future) {
[01:29:26.801]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:26.801]                               info)
[01:29:26.801]                           }
[01:29:26.801]                           else {
[01:29:26.801]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:26.801]                               info, version)
[01:29:26.801]                           }
[01:29:26.801]                           base::stop(msg)
[01:29:26.801]                         }
[01:29:26.801]                       })
[01:29:26.801]                     }
[01:29:26.801]                     options(future.plan = NULL)
[01:29:26.801]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.801]                     future::plan("default", .cleanup = FALSE, 
[01:29:26.801]                       .init = FALSE)
[01:29:26.801]                   }
[01:29:26.801]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[01:29:26.801]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[01:29:26.801]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[01:29:26.801]                 }
[01:29:26.801]                 ...future.workdir <- getwd()
[01:29:26.801]             }
[01:29:26.801]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:26.801]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:26.801]         }
[01:29:26.801]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:26.801]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:26.801]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:26.801]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:26.801]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:26.801]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:26.801]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:26.801]             base::names(...future.oldOptions))
[01:29:26.801]     }
[01:29:26.801]     if (FALSE) {
[01:29:26.801]     }
[01:29:26.801]     else {
[01:29:26.801]         if (TRUE) {
[01:29:26.801]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:26.801]                 open = "w")
[01:29:26.801]         }
[01:29:26.801]         else {
[01:29:26.801]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:26.801]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:26.801]         }
[01:29:26.801]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:26.801]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:26.801]             base::sink(type = "output", split = FALSE)
[01:29:26.801]             base::close(...future.stdout)
[01:29:26.801]         }, add = TRUE)
[01:29:26.801]     }
[01:29:26.801]     ...future.frame <- base::sys.nframe()
[01:29:26.801]     ...future.conditions <- base::list()
[01:29:26.801]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:26.801]     if (FALSE) {
[01:29:26.801]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:26.801]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:26.801]     }
[01:29:26.801]     ...future.result <- base::tryCatch({
[01:29:26.801]         base::withCallingHandlers({
[01:29:26.801]             ...future.value <- base::withVisible(base::local({
[01:29:26.801]                 sample(x, size = 1L)
[01:29:26.801]             }))
[01:29:26.801]             future::FutureResult(value = ...future.value$value, 
[01:29:26.801]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.801]                   ...future.rng), globalenv = if (FALSE) 
[01:29:26.801]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:26.801]                     ...future.globalenv.names))
[01:29:26.801]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:26.801]         }, condition = base::local({
[01:29:26.801]             c <- base::c
[01:29:26.801]             inherits <- base::inherits
[01:29:26.801]             invokeRestart <- base::invokeRestart
[01:29:26.801]             length <- base::length
[01:29:26.801]             list <- base::list
[01:29:26.801]             seq.int <- base::seq.int
[01:29:26.801]             signalCondition <- base::signalCondition
[01:29:26.801]             sys.calls <- base::sys.calls
[01:29:26.801]             `[[` <- base::`[[`
[01:29:26.801]             `+` <- base::`+`
[01:29:26.801]             `<<-` <- base::`<<-`
[01:29:26.801]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:26.801]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:26.801]                   3L)]
[01:29:26.801]             }
[01:29:26.801]             function(cond) {
[01:29:26.801]                 is_error <- inherits(cond, "error")
[01:29:26.801]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:26.801]                   NULL)
[01:29:26.801]                 if (is_error) {
[01:29:26.801]                   sessionInformation <- function() {
[01:29:26.801]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:26.801]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:26.801]                       search = base::search(), system = base::Sys.info())
[01:29:26.801]                   }
[01:29:26.801]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.801]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:26.801]                     cond$call), session = sessionInformation(), 
[01:29:26.801]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:26.801]                   signalCondition(cond)
[01:29:26.801]                 }
[01:29:26.801]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:26.801]                 "immediateCondition"))) {
[01:29:26.801]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:26.801]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.801]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:26.801]                   if (TRUE && !signal) {
[01:29:26.801]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.801]                     {
[01:29:26.801]                       inherits <- base::inherits
[01:29:26.801]                       invokeRestart <- base::invokeRestart
[01:29:26.801]                       is.null <- base::is.null
[01:29:26.801]                       muffled <- FALSE
[01:29:26.801]                       if (inherits(cond, "message")) {
[01:29:26.801]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.801]                         if (muffled) 
[01:29:26.801]                           invokeRestart("muffleMessage")
[01:29:26.801]                       }
[01:29:26.801]                       else if (inherits(cond, "warning")) {
[01:29:26.801]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.801]                         if (muffled) 
[01:29:26.801]                           invokeRestart("muffleWarning")
[01:29:26.801]                       }
[01:29:26.801]                       else if (inherits(cond, "condition")) {
[01:29:26.801]                         if (!is.null(pattern)) {
[01:29:26.801]                           computeRestarts <- base::computeRestarts
[01:29:26.801]                           grepl <- base::grepl
[01:29:26.801]                           restarts <- computeRestarts(cond)
[01:29:26.801]                           for (restart in restarts) {
[01:29:26.801]                             name <- restart$name
[01:29:26.801]                             if (is.null(name)) 
[01:29:26.801]                               next
[01:29:26.801]                             if (!grepl(pattern, name)) 
[01:29:26.801]                               next
[01:29:26.801]                             invokeRestart(restart)
[01:29:26.801]                             muffled <- TRUE
[01:29:26.801]                             break
[01:29:26.801]                           }
[01:29:26.801]                         }
[01:29:26.801]                       }
[01:29:26.801]                       invisible(muffled)
[01:29:26.801]                     }
[01:29:26.801]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.801]                   }
[01:29:26.801]                 }
[01:29:26.801]                 else {
[01:29:26.801]                   if (TRUE) {
[01:29:26.801]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.801]                     {
[01:29:26.801]                       inherits <- base::inherits
[01:29:26.801]                       invokeRestart <- base::invokeRestart
[01:29:26.801]                       is.null <- base::is.null
[01:29:26.801]                       muffled <- FALSE
[01:29:26.801]                       if (inherits(cond, "message")) {
[01:29:26.801]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.801]                         if (muffled) 
[01:29:26.801]                           invokeRestart("muffleMessage")
[01:29:26.801]                       }
[01:29:26.801]                       else if (inherits(cond, "warning")) {
[01:29:26.801]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.801]                         if (muffled) 
[01:29:26.801]                           invokeRestart("muffleWarning")
[01:29:26.801]                       }
[01:29:26.801]                       else if (inherits(cond, "condition")) {
[01:29:26.801]                         if (!is.null(pattern)) {
[01:29:26.801]                           computeRestarts <- base::computeRestarts
[01:29:26.801]                           grepl <- base::grepl
[01:29:26.801]                           restarts <- computeRestarts(cond)
[01:29:26.801]                           for (restart in restarts) {
[01:29:26.801]                             name <- restart$name
[01:29:26.801]                             if (is.null(name)) 
[01:29:26.801]                               next
[01:29:26.801]                             if (!grepl(pattern, name)) 
[01:29:26.801]                               next
[01:29:26.801]                             invokeRestart(restart)
[01:29:26.801]                             muffled <- TRUE
[01:29:26.801]                             break
[01:29:26.801]                           }
[01:29:26.801]                         }
[01:29:26.801]                       }
[01:29:26.801]                       invisible(muffled)
[01:29:26.801]                     }
[01:29:26.801]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.801]                   }
[01:29:26.801]                 }
[01:29:26.801]             }
[01:29:26.801]         }))
[01:29:26.801]     }, error = function(ex) {
[01:29:26.801]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:26.801]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.801]                 ...future.rng), started = ...future.startTime, 
[01:29:26.801]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:26.801]             version = "1.8"), class = "FutureResult")
[01:29:26.801]     }, finally = {
[01:29:26.801]         if (!identical(...future.workdir, getwd())) 
[01:29:26.801]             setwd(...future.workdir)
[01:29:26.801]         {
[01:29:26.801]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:26.801]                 ...future.oldOptions$nwarnings <- NULL
[01:29:26.801]             }
[01:29:26.801]             base::options(...future.oldOptions)
[01:29:26.801]             if (.Platform$OS.type == "windows") {
[01:29:26.801]                 old_names <- names(...future.oldEnvVars)
[01:29:26.801]                 envs <- base::Sys.getenv()
[01:29:26.801]                 names <- names(envs)
[01:29:26.801]                 common <- intersect(names, old_names)
[01:29:26.801]                 added <- setdiff(names, old_names)
[01:29:26.801]                 removed <- setdiff(old_names, names)
[01:29:26.801]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:26.801]                   envs[common]]
[01:29:26.801]                 NAMES <- toupper(changed)
[01:29:26.801]                 args <- list()
[01:29:26.801]                 for (kk in seq_along(NAMES)) {
[01:29:26.801]                   name <- changed[[kk]]
[01:29:26.801]                   NAME <- NAMES[[kk]]
[01:29:26.801]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.801]                     next
[01:29:26.801]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.801]                 }
[01:29:26.801]                 NAMES <- toupper(added)
[01:29:26.801]                 for (kk in seq_along(NAMES)) {
[01:29:26.801]                   name <- added[[kk]]
[01:29:26.801]                   NAME <- NAMES[[kk]]
[01:29:26.801]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.801]                     next
[01:29:26.801]                   args[[name]] <- ""
[01:29:26.801]                 }
[01:29:26.801]                 NAMES <- toupper(removed)
[01:29:26.801]                 for (kk in seq_along(NAMES)) {
[01:29:26.801]                   name <- removed[[kk]]
[01:29:26.801]                   NAME <- NAMES[[kk]]
[01:29:26.801]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.801]                     next
[01:29:26.801]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.801]                 }
[01:29:26.801]                 if (length(args) > 0) 
[01:29:26.801]                   base::do.call(base::Sys.setenv, args = args)
[01:29:26.801]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:26.801]             }
[01:29:26.801]             else {
[01:29:26.801]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:26.801]             }
[01:29:26.801]             {
[01:29:26.801]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:26.801]                   0L) {
[01:29:26.801]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:26.801]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:26.801]                   base::options(opts)
[01:29:26.801]                 }
[01:29:26.801]                 {
[01:29:26.801]                   {
[01:29:26.801]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:26.801]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:26.801]                     -1344458670L), envir = base::globalenv(), 
[01:29:26.801]                       inherits = FALSE)
[01:29:26.801]                     NULL
[01:29:26.801]                   }
[01:29:26.801]                   options(future.plan = NULL)
[01:29:26.801]                   if (is.na(NA_character_)) 
[01:29:26.801]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.801]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:26.801]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:26.801]                   {
[01:29:26.801]                     future <- SequentialFuture(..., envir = envir)
[01:29:26.801]                     if (!future$lazy) 
[01:29:26.801]                       future <- run(future)
[01:29:26.801]                     invisible(future)
[01:29:26.801]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:26.801]                 }
[01:29:26.801]             }
[01:29:26.801]         }
[01:29:26.801]     })
[01:29:26.801]     if (TRUE) {
[01:29:26.801]         base::sink(type = "output", split = FALSE)
[01:29:26.801]         if (TRUE) {
[01:29:26.801]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:26.801]         }
[01:29:26.801]         else {
[01:29:26.801]             ...future.result["stdout"] <- base::list(NULL)
[01:29:26.801]         }
[01:29:26.801]         base::close(...future.stdout)
[01:29:26.801]         ...future.stdout <- NULL
[01:29:26.801]     }
[01:29:26.801]     ...future.result$conditions <- ...future.conditions
[01:29:26.801]     ...future.result$finished <- base::Sys.time()
[01:29:26.801]     ...future.result
[01:29:26.801] }
[01:29:26.805] assign_globals() ...
[01:29:26.806] List of 1
[01:29:26.806]  $ x: int [1:4] 0 1 2 3
[01:29:26.806]  - attr(*, "where")=List of 1
[01:29:26.806]   ..$ x:<environment: R_EmptyEnv> 
[01:29:26.806]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:26.806]  - attr(*, "resolved")= logi FALSE
[01:29:26.806]  - attr(*, "total_size")= num 64
[01:29:26.806]  - attr(*, "already-done")= logi TRUE
[01:29:26.809] - copied 'x' to environment
[01:29:26.809] assign_globals() ... done
[01:29:26.810] plan(): Setting new future strategy stack:
[01:29:26.810] List of future strategies:
[01:29:26.810] 1. sequential:
[01:29:26.810]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.810]    - tweaked: FALSE
[01:29:26.810]    - call: NULL
[01:29:26.811] plan(): nbrOfWorkers() = 1
[01:29:26.812] plan(): Setting new future strategy stack:
[01:29:26.812] List of future strategies:
[01:29:26.812] 1. sequential:
[01:29:26.812]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.812]    - tweaked: FALSE
[01:29:26.812]    - call: plan(strategy)
[01:29:26.813] plan(): nbrOfWorkers() = 1
[01:29:26.813] SequentialFuture started (and completed)
[01:29:26.813] - Launch lazy future ... done
[01:29:26.813] run() for 'SequentialFuture' ... done
[01:29:26.814] getGlobalsAndPackages() ...
[01:29:26.814] Searching for globals...
[01:29:26.815] - globals found: [3] '{', 'sample', 'x'
[01:29:26.815] Searching for globals ... DONE
[01:29:26.815] Resolving globals: FALSE
[01:29:26.816] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:26.816] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:26.817] - globals: [1] 'x'
[01:29:26.817] 
[01:29:26.817] getGlobalsAndPackages() ... DONE
[01:29:26.817] run() for 'Future' ...
[01:29:26.817] - state: 'created'
[01:29:26.818] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:26.818] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:26.818] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:26.818]   - Field: 'label'
[01:29:26.818]   - Field: 'local'
[01:29:26.819]   - Field: 'owner'
[01:29:26.819]   - Field: 'envir'
[01:29:26.819]   - Field: 'packages'
[01:29:26.819]   - Field: 'gc'
[01:29:26.819]   - Field: 'conditions'
[01:29:26.820]   - Field: 'expr'
[01:29:26.820]   - Field: 'uuid'
[01:29:26.820]   - Field: 'seed'
[01:29:26.820]   - Field: 'version'
[01:29:26.820]   - Field: 'result'
[01:29:26.820]   - Field: 'asynchronous'
[01:29:26.821]   - Field: 'calls'
[01:29:26.821]   - Field: 'globals'
[01:29:26.821]   - Field: 'stdout'
[01:29:26.821]   - Field: 'earlySignal'
[01:29:26.821]   - Field: 'lazy'
[01:29:26.821]   - Field: 'state'
[01:29:26.822] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:26.822] - Launch lazy future ...
[01:29:26.822] Packages needed by the future expression (n = 0): <none>
[01:29:26.822] Packages needed by future strategies (n = 0): <none>
[01:29:26.823] {
[01:29:26.823]     {
[01:29:26.823]         {
[01:29:26.823]             ...future.startTime <- base::Sys.time()
[01:29:26.823]             {
[01:29:26.823]                 {
[01:29:26.823]                   {
[01:29:26.823]                     {
[01:29:26.823]                       base::local({
[01:29:26.823]                         has_future <- base::requireNamespace("future", 
[01:29:26.823]                           quietly = TRUE)
[01:29:26.823]                         if (has_future) {
[01:29:26.823]                           ns <- base::getNamespace("future")
[01:29:26.823]                           version <- ns[[".package"]][["version"]]
[01:29:26.823]                           if (is.null(version)) 
[01:29:26.823]                             version <- utils::packageVersion("future")
[01:29:26.823]                         }
[01:29:26.823]                         else {
[01:29:26.823]                           version <- NULL
[01:29:26.823]                         }
[01:29:26.823]                         if (!has_future || version < "1.8.0") {
[01:29:26.823]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:26.823]                             "", base::R.version$version.string), 
[01:29:26.823]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:26.823]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:26.823]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:26.823]                               "release", "version")], collapse = " "), 
[01:29:26.823]                             hostname = base::Sys.info()[["nodename"]])
[01:29:26.823]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:26.823]                             info)
[01:29:26.823]                           info <- base::paste(info, collapse = "; ")
[01:29:26.823]                           if (!has_future) {
[01:29:26.823]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:26.823]                               info)
[01:29:26.823]                           }
[01:29:26.823]                           else {
[01:29:26.823]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:26.823]                               info, version)
[01:29:26.823]                           }
[01:29:26.823]                           base::stop(msg)
[01:29:26.823]                         }
[01:29:26.823]                       })
[01:29:26.823]                     }
[01:29:26.823]                     options(future.plan = NULL)
[01:29:26.823]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.823]                     future::plan("default", .cleanup = FALSE, 
[01:29:26.823]                       .init = FALSE)
[01:29:26.823]                   }
[01:29:26.823]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[01:29:26.823]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[01:29:26.823]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[01:29:26.823]                 }
[01:29:26.823]                 ...future.workdir <- getwd()
[01:29:26.823]             }
[01:29:26.823]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:26.823]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:26.823]         }
[01:29:26.823]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:26.823]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:26.823]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:26.823]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:26.823]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:26.823]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:26.823]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:26.823]             base::names(...future.oldOptions))
[01:29:26.823]     }
[01:29:26.823]     if (FALSE) {
[01:29:26.823]     }
[01:29:26.823]     else {
[01:29:26.823]         if (TRUE) {
[01:29:26.823]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:26.823]                 open = "w")
[01:29:26.823]         }
[01:29:26.823]         else {
[01:29:26.823]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:26.823]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:26.823]         }
[01:29:26.823]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:26.823]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:26.823]             base::sink(type = "output", split = FALSE)
[01:29:26.823]             base::close(...future.stdout)
[01:29:26.823]         }, add = TRUE)
[01:29:26.823]     }
[01:29:26.823]     ...future.frame <- base::sys.nframe()
[01:29:26.823]     ...future.conditions <- base::list()
[01:29:26.823]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:26.823]     if (FALSE) {
[01:29:26.823]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:26.823]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:26.823]     }
[01:29:26.823]     ...future.result <- base::tryCatch({
[01:29:26.823]         base::withCallingHandlers({
[01:29:26.823]             ...future.value <- base::withVisible(base::local({
[01:29:26.823]                 sample(x, size = 1L)
[01:29:26.823]             }))
[01:29:26.823]             future::FutureResult(value = ...future.value$value, 
[01:29:26.823]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.823]                   ...future.rng), globalenv = if (FALSE) 
[01:29:26.823]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:26.823]                     ...future.globalenv.names))
[01:29:26.823]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:26.823]         }, condition = base::local({
[01:29:26.823]             c <- base::c
[01:29:26.823]             inherits <- base::inherits
[01:29:26.823]             invokeRestart <- base::invokeRestart
[01:29:26.823]             length <- base::length
[01:29:26.823]             list <- base::list
[01:29:26.823]             seq.int <- base::seq.int
[01:29:26.823]             signalCondition <- base::signalCondition
[01:29:26.823]             sys.calls <- base::sys.calls
[01:29:26.823]             `[[` <- base::`[[`
[01:29:26.823]             `+` <- base::`+`
[01:29:26.823]             `<<-` <- base::`<<-`
[01:29:26.823]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:26.823]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:26.823]                   3L)]
[01:29:26.823]             }
[01:29:26.823]             function(cond) {
[01:29:26.823]                 is_error <- inherits(cond, "error")
[01:29:26.823]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:26.823]                   NULL)
[01:29:26.823]                 if (is_error) {
[01:29:26.823]                   sessionInformation <- function() {
[01:29:26.823]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:26.823]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:26.823]                       search = base::search(), system = base::Sys.info())
[01:29:26.823]                   }
[01:29:26.823]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.823]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:26.823]                     cond$call), session = sessionInformation(), 
[01:29:26.823]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:26.823]                   signalCondition(cond)
[01:29:26.823]                 }
[01:29:26.823]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:26.823]                 "immediateCondition"))) {
[01:29:26.823]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:26.823]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.823]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:26.823]                   if (TRUE && !signal) {
[01:29:26.823]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.823]                     {
[01:29:26.823]                       inherits <- base::inherits
[01:29:26.823]                       invokeRestart <- base::invokeRestart
[01:29:26.823]                       is.null <- base::is.null
[01:29:26.823]                       muffled <- FALSE
[01:29:26.823]                       if (inherits(cond, "message")) {
[01:29:26.823]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.823]                         if (muffled) 
[01:29:26.823]                           invokeRestart("muffleMessage")
[01:29:26.823]                       }
[01:29:26.823]                       else if (inherits(cond, "warning")) {
[01:29:26.823]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.823]                         if (muffled) 
[01:29:26.823]                           invokeRestart("muffleWarning")
[01:29:26.823]                       }
[01:29:26.823]                       else if (inherits(cond, "condition")) {
[01:29:26.823]                         if (!is.null(pattern)) {
[01:29:26.823]                           computeRestarts <- base::computeRestarts
[01:29:26.823]                           grepl <- base::grepl
[01:29:26.823]                           restarts <- computeRestarts(cond)
[01:29:26.823]                           for (restart in restarts) {
[01:29:26.823]                             name <- restart$name
[01:29:26.823]                             if (is.null(name)) 
[01:29:26.823]                               next
[01:29:26.823]                             if (!grepl(pattern, name)) 
[01:29:26.823]                               next
[01:29:26.823]                             invokeRestart(restart)
[01:29:26.823]                             muffled <- TRUE
[01:29:26.823]                             break
[01:29:26.823]                           }
[01:29:26.823]                         }
[01:29:26.823]                       }
[01:29:26.823]                       invisible(muffled)
[01:29:26.823]                     }
[01:29:26.823]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.823]                   }
[01:29:26.823]                 }
[01:29:26.823]                 else {
[01:29:26.823]                   if (TRUE) {
[01:29:26.823]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.823]                     {
[01:29:26.823]                       inherits <- base::inherits
[01:29:26.823]                       invokeRestart <- base::invokeRestart
[01:29:26.823]                       is.null <- base::is.null
[01:29:26.823]                       muffled <- FALSE
[01:29:26.823]                       if (inherits(cond, "message")) {
[01:29:26.823]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.823]                         if (muffled) 
[01:29:26.823]                           invokeRestart("muffleMessage")
[01:29:26.823]                       }
[01:29:26.823]                       else if (inherits(cond, "warning")) {
[01:29:26.823]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.823]                         if (muffled) 
[01:29:26.823]                           invokeRestart("muffleWarning")
[01:29:26.823]                       }
[01:29:26.823]                       else if (inherits(cond, "condition")) {
[01:29:26.823]                         if (!is.null(pattern)) {
[01:29:26.823]                           computeRestarts <- base::computeRestarts
[01:29:26.823]                           grepl <- base::grepl
[01:29:26.823]                           restarts <- computeRestarts(cond)
[01:29:26.823]                           for (restart in restarts) {
[01:29:26.823]                             name <- restart$name
[01:29:26.823]                             if (is.null(name)) 
[01:29:26.823]                               next
[01:29:26.823]                             if (!grepl(pattern, name)) 
[01:29:26.823]                               next
[01:29:26.823]                             invokeRestart(restart)
[01:29:26.823]                             muffled <- TRUE
[01:29:26.823]                             break
[01:29:26.823]                           }
[01:29:26.823]                         }
[01:29:26.823]                       }
[01:29:26.823]                       invisible(muffled)
[01:29:26.823]                     }
[01:29:26.823]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.823]                   }
[01:29:26.823]                 }
[01:29:26.823]             }
[01:29:26.823]         }))
[01:29:26.823]     }, error = function(ex) {
[01:29:26.823]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:26.823]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.823]                 ...future.rng), started = ...future.startTime, 
[01:29:26.823]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:26.823]             version = "1.8"), class = "FutureResult")
[01:29:26.823]     }, finally = {
[01:29:26.823]         if (!identical(...future.workdir, getwd())) 
[01:29:26.823]             setwd(...future.workdir)
[01:29:26.823]         {
[01:29:26.823]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:26.823]                 ...future.oldOptions$nwarnings <- NULL
[01:29:26.823]             }
[01:29:26.823]             base::options(...future.oldOptions)
[01:29:26.823]             if (.Platform$OS.type == "windows") {
[01:29:26.823]                 old_names <- names(...future.oldEnvVars)
[01:29:26.823]                 envs <- base::Sys.getenv()
[01:29:26.823]                 names <- names(envs)
[01:29:26.823]                 common <- intersect(names, old_names)
[01:29:26.823]                 added <- setdiff(names, old_names)
[01:29:26.823]                 removed <- setdiff(old_names, names)
[01:29:26.823]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:26.823]                   envs[common]]
[01:29:26.823]                 NAMES <- toupper(changed)
[01:29:26.823]                 args <- list()
[01:29:26.823]                 for (kk in seq_along(NAMES)) {
[01:29:26.823]                   name <- changed[[kk]]
[01:29:26.823]                   NAME <- NAMES[[kk]]
[01:29:26.823]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.823]                     next
[01:29:26.823]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.823]                 }
[01:29:26.823]                 NAMES <- toupper(added)
[01:29:26.823]                 for (kk in seq_along(NAMES)) {
[01:29:26.823]                   name <- added[[kk]]
[01:29:26.823]                   NAME <- NAMES[[kk]]
[01:29:26.823]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.823]                     next
[01:29:26.823]                   args[[name]] <- ""
[01:29:26.823]                 }
[01:29:26.823]                 NAMES <- toupper(removed)
[01:29:26.823]                 for (kk in seq_along(NAMES)) {
[01:29:26.823]                   name <- removed[[kk]]
[01:29:26.823]                   NAME <- NAMES[[kk]]
[01:29:26.823]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.823]                     next
[01:29:26.823]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.823]                 }
[01:29:26.823]                 if (length(args) > 0) 
[01:29:26.823]                   base::do.call(base::Sys.setenv, args = args)
[01:29:26.823]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:26.823]             }
[01:29:26.823]             else {
[01:29:26.823]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:26.823]             }
[01:29:26.823]             {
[01:29:26.823]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:26.823]                   0L) {
[01:29:26.823]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:26.823]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:26.823]                   base::options(opts)
[01:29:26.823]                 }
[01:29:26.823]                 {
[01:29:26.823]                   {
[01:29:26.823]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:26.823]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:26.823]                     -1344458670L), envir = base::globalenv(), 
[01:29:26.823]                       inherits = FALSE)
[01:29:26.823]                     NULL
[01:29:26.823]                   }
[01:29:26.823]                   options(future.plan = NULL)
[01:29:26.823]                   if (is.na(NA_character_)) 
[01:29:26.823]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.823]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:26.823]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:26.823]                   {
[01:29:26.823]                     future <- SequentialFuture(..., envir = envir)
[01:29:26.823]                     if (!future$lazy) 
[01:29:26.823]                       future <- run(future)
[01:29:26.823]                     invisible(future)
[01:29:26.823]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:26.823]                 }
[01:29:26.823]             }
[01:29:26.823]         }
[01:29:26.823]     })
[01:29:26.823]     if (TRUE) {
[01:29:26.823]         base::sink(type = "output", split = FALSE)
[01:29:26.823]         if (TRUE) {
[01:29:26.823]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:26.823]         }
[01:29:26.823]         else {
[01:29:26.823]             ...future.result["stdout"] <- base::list(NULL)
[01:29:26.823]         }
[01:29:26.823]         base::close(...future.stdout)
[01:29:26.823]         ...future.stdout <- NULL
[01:29:26.823]     }
[01:29:26.823]     ...future.result$conditions <- ...future.conditions
[01:29:26.823]     ...future.result$finished <- base::Sys.time()
[01:29:26.823]     ...future.result
[01:29:26.823] }
[01:29:26.827] assign_globals() ...
[01:29:26.827] List of 1
[01:29:26.827]  $ x: int [1:4] 0 1 2 3
[01:29:26.827]  - attr(*, "where")=List of 1
[01:29:26.827]   ..$ x:<environment: R_EmptyEnv> 
[01:29:26.827]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:26.827]  - attr(*, "resolved")= logi FALSE
[01:29:26.827]  - attr(*, "total_size")= num 64
[01:29:26.827]  - attr(*, "already-done")= logi TRUE
[01:29:26.830] - copied 'x' to environment
[01:29:26.830] assign_globals() ... done
[01:29:26.831] plan(): Setting new future strategy stack:
[01:29:26.831] List of future strategies:
[01:29:26.831] 1. sequential:
[01:29:26.831]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.831]    - tweaked: FALSE
[01:29:26.831]    - call: NULL
[01:29:26.832] plan(): nbrOfWorkers() = 1
[01:29:26.833] plan(): Setting new future strategy stack:
[01:29:26.833] List of future strategies:
[01:29:26.833] 1. sequential:
[01:29:26.833]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.833]    - tweaked: FALSE
[01:29:26.833]    - call: plan(strategy)
[01:29:26.834] plan(): nbrOfWorkers() = 1
[01:29:26.834] SequentialFuture started (and completed)
[01:29:26.834] - Launch lazy future ... done
[01:29:26.835] run() for 'SequentialFuture' ... done
[01:29:26.836] resolve() on list ...
[01:29:26.836]  recursive: 0
[01:29:26.836]  length: 4
[01:29:26.836] 
[01:29:26.836] resolved() for 'SequentialFuture' ...
[01:29:26.837] - state: 'finished'
[01:29:26.837] - run: TRUE
[01:29:26.837] - result: 'FutureResult'
[01:29:26.837] resolved() for 'SequentialFuture' ... done
[01:29:26.837] Future #1
[01:29:26.838] signalConditionsASAP(SequentialFuture, pos=1) ...
[01:29:26.838] - nx: 4
[01:29:26.838] - relay: TRUE
[01:29:26.838] - stdout: TRUE
[01:29:26.838] - signal: TRUE
[01:29:26.838] - resignal: FALSE
[01:29:26.839] - force: TRUE
[01:29:26.839] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:26.839] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:26.839]  - until=1
[01:29:26.839]  - relaying element #1
[01:29:26.839] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:26.840] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:26.840] signalConditionsASAP(SequentialFuture, pos=1) ... done
[01:29:26.840]  length: 3 (resolved future 1)
[01:29:26.840] resolved() for 'SequentialFuture' ...
[01:29:26.840] - state: 'finished'
[01:29:26.841] - run: TRUE
[01:29:26.841] - result: 'FutureResult'
[01:29:26.841] resolved() for 'SequentialFuture' ... done
[01:29:26.841] Future #2
[01:29:26.841] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:29:26.841] - nx: 4
[01:29:26.842] - relay: TRUE
[01:29:26.842] - stdout: TRUE
[01:29:26.842] - signal: TRUE
[01:29:26.842] - resignal: FALSE
[01:29:26.842] - force: TRUE
[01:29:26.842] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:26.843] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:26.843]  - until=2
[01:29:26.843]  - relaying element #2
[01:29:26.843] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:26.843] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:26.844] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:29:26.844]  length: 2 (resolved future 2)
[01:29:26.844] resolved() for 'SequentialFuture' ...
[01:29:26.844] - state: 'finished'
[01:29:26.844] - run: TRUE
[01:29:26.844] - result: 'FutureResult'
[01:29:26.845] resolved() for 'SequentialFuture' ... done
[01:29:26.845] Future #3
[01:29:26.845] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:29:26.845] - nx: 4
[01:29:26.845] - relay: TRUE
[01:29:26.846] - stdout: TRUE
[01:29:26.846] - signal: TRUE
[01:29:26.846] - resignal: FALSE
[01:29:26.846] - force: TRUE
[01:29:26.846] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:26.846] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:26.846]  - until=3
[01:29:26.847]  - relaying element #3
[01:29:26.847] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:26.847] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:26.847] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:29:26.847]  length: 1 (resolved future 3)
[01:29:26.848] resolved() for 'SequentialFuture' ...
[01:29:26.848] - state: 'finished'
[01:29:26.848] - run: TRUE
[01:29:26.848] - result: 'FutureResult'
[01:29:26.848] resolved() for 'SequentialFuture' ... done
[01:29:26.849] Future #4
[01:29:26.849] signalConditionsASAP(SequentialFuture, pos=4) ...
[01:29:26.849] - nx: 4
[01:29:26.849] - relay: TRUE
[01:29:26.849] - stdout: TRUE
[01:29:26.849] - signal: TRUE
[01:29:26.849] - resignal: FALSE
[01:29:26.850] - force: TRUE
[01:29:26.850] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:26.850] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:26.850]  - until=4
[01:29:26.850]  - relaying element #4
[01:29:26.851] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:26.851] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:26.851] signalConditionsASAP(SequentialFuture, pos=4) ... done
[01:29:26.851]  length: 0 (resolved future 4)
[01:29:26.851] Relaying remaining futures
[01:29:26.851] signalConditionsASAP(NULL, pos=0) ...
[01:29:26.851] - nx: 4
[01:29:26.852] - relay: TRUE
[01:29:26.852] - stdout: TRUE
[01:29:26.852] - signal: TRUE
[01:29:26.852] - resignal: FALSE
[01:29:26.852] - force: TRUE
[01:29:26.852] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:26.853] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[01:29:26.853] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:26.853] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:26.853] signalConditionsASAP(NULL, pos=0) ... done
[01:29:26.853] resolve() on list ... DONE
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[01:29:26.854] getGlobalsAndPackages() ...
[01:29:26.854] Searching for globals...
[01:29:26.855] - globals found: [3] '{', 'sample', 'x'
[01:29:26.855] Searching for globals ... DONE
[01:29:26.856] Resolving globals: FALSE
[01:29:26.856] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:26.856] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:26.857] - globals: [1] 'x'
[01:29:26.857] 
[01:29:26.857] getGlobalsAndPackages() ... DONE
[01:29:26.857] run() for 'Future' ...
[01:29:26.857] - state: 'created'
[01:29:26.858] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:26.858] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:26.858] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:26.858]   - Field: 'label'
[01:29:26.859]   - Field: 'local'
[01:29:26.859]   - Field: 'owner'
[01:29:26.859]   - Field: 'envir'
[01:29:26.859]   - Field: 'packages'
[01:29:26.859]   - Field: 'gc'
[01:29:26.859]   - Field: 'conditions'
[01:29:26.860]   - Field: 'expr'
[01:29:26.860]   - Field: 'uuid'
[01:29:26.860]   - Field: 'seed'
[01:29:26.860]   - Field: 'version'
[01:29:26.860]   - Field: 'result'
[01:29:26.860]   - Field: 'asynchronous'
[01:29:26.861]   - Field: 'calls'
[01:29:26.861]   - Field: 'globals'
[01:29:26.861]   - Field: 'stdout'
[01:29:26.861]   - Field: 'earlySignal'
[01:29:26.861]   - Field: 'lazy'
[01:29:26.862]   - Field: 'state'
[01:29:26.862] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:26.862] - Launch lazy future ...
[01:29:26.862] Packages needed by the future expression (n = 0): <none>
[01:29:26.862] Packages needed by future strategies (n = 0): <none>
[01:29:26.863] {
[01:29:26.863]     {
[01:29:26.863]         {
[01:29:26.863]             ...future.startTime <- base::Sys.time()
[01:29:26.863]             {
[01:29:26.863]                 {
[01:29:26.863]                   {
[01:29:26.863]                     {
[01:29:26.863]                       base::local({
[01:29:26.863]                         has_future <- base::requireNamespace("future", 
[01:29:26.863]                           quietly = TRUE)
[01:29:26.863]                         if (has_future) {
[01:29:26.863]                           ns <- base::getNamespace("future")
[01:29:26.863]                           version <- ns[[".package"]][["version"]]
[01:29:26.863]                           if (is.null(version)) 
[01:29:26.863]                             version <- utils::packageVersion("future")
[01:29:26.863]                         }
[01:29:26.863]                         else {
[01:29:26.863]                           version <- NULL
[01:29:26.863]                         }
[01:29:26.863]                         if (!has_future || version < "1.8.0") {
[01:29:26.863]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:26.863]                             "", base::R.version$version.string), 
[01:29:26.863]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:26.863]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:26.863]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:26.863]                               "release", "version")], collapse = " "), 
[01:29:26.863]                             hostname = base::Sys.info()[["nodename"]])
[01:29:26.863]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:26.863]                             info)
[01:29:26.863]                           info <- base::paste(info, collapse = "; ")
[01:29:26.863]                           if (!has_future) {
[01:29:26.863]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:26.863]                               info)
[01:29:26.863]                           }
[01:29:26.863]                           else {
[01:29:26.863]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:26.863]                               info, version)
[01:29:26.863]                           }
[01:29:26.863]                           base::stop(msg)
[01:29:26.863]                         }
[01:29:26.863]                       })
[01:29:26.863]                     }
[01:29:26.863]                     options(future.plan = NULL)
[01:29:26.863]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.863]                     future::plan("default", .cleanup = FALSE, 
[01:29:26.863]                       .init = FALSE)
[01:29:26.863]                   }
[01:29:26.863]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[01:29:26.863]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[01:29:26.863]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[01:29:26.863]                 }
[01:29:26.863]                 ...future.workdir <- getwd()
[01:29:26.863]             }
[01:29:26.863]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:26.863]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:26.863]         }
[01:29:26.863]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:26.863]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:26.863]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:26.863]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:26.863]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:26.863]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:26.863]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:26.863]             base::names(...future.oldOptions))
[01:29:26.863]     }
[01:29:26.863]     if (FALSE) {
[01:29:26.863]     }
[01:29:26.863]     else {
[01:29:26.863]         if (TRUE) {
[01:29:26.863]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:26.863]                 open = "w")
[01:29:26.863]         }
[01:29:26.863]         else {
[01:29:26.863]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:26.863]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:26.863]         }
[01:29:26.863]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:26.863]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:26.863]             base::sink(type = "output", split = FALSE)
[01:29:26.863]             base::close(...future.stdout)
[01:29:26.863]         }, add = TRUE)
[01:29:26.863]     }
[01:29:26.863]     ...future.frame <- base::sys.nframe()
[01:29:26.863]     ...future.conditions <- base::list()
[01:29:26.863]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:26.863]     if (FALSE) {
[01:29:26.863]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:26.863]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:26.863]     }
[01:29:26.863]     ...future.result <- base::tryCatch({
[01:29:26.863]         base::withCallingHandlers({
[01:29:26.863]             ...future.value <- base::withVisible(base::local({
[01:29:26.863]                 sample(x, size = 1L)
[01:29:26.863]             }))
[01:29:26.863]             future::FutureResult(value = ...future.value$value, 
[01:29:26.863]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.863]                   ...future.rng), globalenv = if (FALSE) 
[01:29:26.863]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:26.863]                     ...future.globalenv.names))
[01:29:26.863]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:26.863]         }, condition = base::local({
[01:29:26.863]             c <- base::c
[01:29:26.863]             inherits <- base::inherits
[01:29:26.863]             invokeRestart <- base::invokeRestart
[01:29:26.863]             length <- base::length
[01:29:26.863]             list <- base::list
[01:29:26.863]             seq.int <- base::seq.int
[01:29:26.863]             signalCondition <- base::signalCondition
[01:29:26.863]             sys.calls <- base::sys.calls
[01:29:26.863]             `[[` <- base::`[[`
[01:29:26.863]             `+` <- base::`+`
[01:29:26.863]             `<<-` <- base::`<<-`
[01:29:26.863]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:26.863]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:26.863]                   3L)]
[01:29:26.863]             }
[01:29:26.863]             function(cond) {
[01:29:26.863]                 is_error <- inherits(cond, "error")
[01:29:26.863]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:26.863]                   NULL)
[01:29:26.863]                 if (is_error) {
[01:29:26.863]                   sessionInformation <- function() {
[01:29:26.863]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:26.863]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:26.863]                       search = base::search(), system = base::Sys.info())
[01:29:26.863]                   }
[01:29:26.863]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.863]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:26.863]                     cond$call), session = sessionInformation(), 
[01:29:26.863]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:26.863]                   signalCondition(cond)
[01:29:26.863]                 }
[01:29:26.863]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:26.863]                 "immediateCondition"))) {
[01:29:26.863]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:26.863]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.863]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:26.863]                   if (TRUE && !signal) {
[01:29:26.863]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.863]                     {
[01:29:26.863]                       inherits <- base::inherits
[01:29:26.863]                       invokeRestart <- base::invokeRestart
[01:29:26.863]                       is.null <- base::is.null
[01:29:26.863]                       muffled <- FALSE
[01:29:26.863]                       if (inherits(cond, "message")) {
[01:29:26.863]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.863]                         if (muffled) 
[01:29:26.863]                           invokeRestart("muffleMessage")
[01:29:26.863]                       }
[01:29:26.863]                       else if (inherits(cond, "warning")) {
[01:29:26.863]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.863]                         if (muffled) 
[01:29:26.863]                           invokeRestart("muffleWarning")
[01:29:26.863]                       }
[01:29:26.863]                       else if (inherits(cond, "condition")) {
[01:29:26.863]                         if (!is.null(pattern)) {
[01:29:26.863]                           computeRestarts <- base::computeRestarts
[01:29:26.863]                           grepl <- base::grepl
[01:29:26.863]                           restarts <- computeRestarts(cond)
[01:29:26.863]                           for (restart in restarts) {
[01:29:26.863]                             name <- restart$name
[01:29:26.863]                             if (is.null(name)) 
[01:29:26.863]                               next
[01:29:26.863]                             if (!grepl(pattern, name)) 
[01:29:26.863]                               next
[01:29:26.863]                             invokeRestart(restart)
[01:29:26.863]                             muffled <- TRUE
[01:29:26.863]                             break
[01:29:26.863]                           }
[01:29:26.863]                         }
[01:29:26.863]                       }
[01:29:26.863]                       invisible(muffled)
[01:29:26.863]                     }
[01:29:26.863]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.863]                   }
[01:29:26.863]                 }
[01:29:26.863]                 else {
[01:29:26.863]                   if (TRUE) {
[01:29:26.863]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.863]                     {
[01:29:26.863]                       inherits <- base::inherits
[01:29:26.863]                       invokeRestart <- base::invokeRestart
[01:29:26.863]                       is.null <- base::is.null
[01:29:26.863]                       muffled <- FALSE
[01:29:26.863]                       if (inherits(cond, "message")) {
[01:29:26.863]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.863]                         if (muffled) 
[01:29:26.863]                           invokeRestart("muffleMessage")
[01:29:26.863]                       }
[01:29:26.863]                       else if (inherits(cond, "warning")) {
[01:29:26.863]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.863]                         if (muffled) 
[01:29:26.863]                           invokeRestart("muffleWarning")
[01:29:26.863]                       }
[01:29:26.863]                       else if (inherits(cond, "condition")) {
[01:29:26.863]                         if (!is.null(pattern)) {
[01:29:26.863]                           computeRestarts <- base::computeRestarts
[01:29:26.863]                           grepl <- base::grepl
[01:29:26.863]                           restarts <- computeRestarts(cond)
[01:29:26.863]                           for (restart in restarts) {
[01:29:26.863]                             name <- restart$name
[01:29:26.863]                             if (is.null(name)) 
[01:29:26.863]                               next
[01:29:26.863]                             if (!grepl(pattern, name)) 
[01:29:26.863]                               next
[01:29:26.863]                             invokeRestart(restart)
[01:29:26.863]                             muffled <- TRUE
[01:29:26.863]                             break
[01:29:26.863]                           }
[01:29:26.863]                         }
[01:29:26.863]                       }
[01:29:26.863]                       invisible(muffled)
[01:29:26.863]                     }
[01:29:26.863]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.863]                   }
[01:29:26.863]                 }
[01:29:26.863]             }
[01:29:26.863]         }))
[01:29:26.863]     }, error = function(ex) {
[01:29:26.863]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:26.863]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.863]                 ...future.rng), started = ...future.startTime, 
[01:29:26.863]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:26.863]             version = "1.8"), class = "FutureResult")
[01:29:26.863]     }, finally = {
[01:29:26.863]         if (!identical(...future.workdir, getwd())) 
[01:29:26.863]             setwd(...future.workdir)
[01:29:26.863]         {
[01:29:26.863]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:26.863]                 ...future.oldOptions$nwarnings <- NULL
[01:29:26.863]             }
[01:29:26.863]             base::options(...future.oldOptions)
[01:29:26.863]             if (.Platform$OS.type == "windows") {
[01:29:26.863]                 old_names <- names(...future.oldEnvVars)
[01:29:26.863]                 envs <- base::Sys.getenv()
[01:29:26.863]                 names <- names(envs)
[01:29:26.863]                 common <- intersect(names, old_names)
[01:29:26.863]                 added <- setdiff(names, old_names)
[01:29:26.863]                 removed <- setdiff(old_names, names)
[01:29:26.863]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:26.863]                   envs[common]]
[01:29:26.863]                 NAMES <- toupper(changed)
[01:29:26.863]                 args <- list()
[01:29:26.863]                 for (kk in seq_along(NAMES)) {
[01:29:26.863]                   name <- changed[[kk]]
[01:29:26.863]                   NAME <- NAMES[[kk]]
[01:29:26.863]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.863]                     next
[01:29:26.863]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.863]                 }
[01:29:26.863]                 NAMES <- toupper(added)
[01:29:26.863]                 for (kk in seq_along(NAMES)) {
[01:29:26.863]                   name <- added[[kk]]
[01:29:26.863]                   NAME <- NAMES[[kk]]
[01:29:26.863]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.863]                     next
[01:29:26.863]                   args[[name]] <- ""
[01:29:26.863]                 }
[01:29:26.863]                 NAMES <- toupper(removed)
[01:29:26.863]                 for (kk in seq_along(NAMES)) {
[01:29:26.863]                   name <- removed[[kk]]
[01:29:26.863]                   NAME <- NAMES[[kk]]
[01:29:26.863]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.863]                     next
[01:29:26.863]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.863]                 }
[01:29:26.863]                 if (length(args) > 0) 
[01:29:26.863]                   base::do.call(base::Sys.setenv, args = args)
[01:29:26.863]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:26.863]             }
[01:29:26.863]             else {
[01:29:26.863]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:26.863]             }
[01:29:26.863]             {
[01:29:26.863]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:26.863]                   0L) {
[01:29:26.863]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:26.863]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:26.863]                   base::options(opts)
[01:29:26.863]                 }
[01:29:26.863]                 {
[01:29:26.863]                   {
[01:29:26.863]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:26.863]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:26.863]                     -1344458670L), envir = base::globalenv(), 
[01:29:26.863]                       inherits = FALSE)
[01:29:26.863]                     NULL
[01:29:26.863]                   }
[01:29:26.863]                   options(future.plan = NULL)
[01:29:26.863]                   if (is.na(NA_character_)) 
[01:29:26.863]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.863]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:26.863]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:26.863]                   {
[01:29:26.863]                     future <- SequentialFuture(..., envir = envir)
[01:29:26.863]                     if (!future$lazy) 
[01:29:26.863]                       future <- run(future)
[01:29:26.863]                     invisible(future)
[01:29:26.863]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:26.863]                 }
[01:29:26.863]             }
[01:29:26.863]         }
[01:29:26.863]     })
[01:29:26.863]     if (TRUE) {
[01:29:26.863]         base::sink(type = "output", split = FALSE)
[01:29:26.863]         if (TRUE) {
[01:29:26.863]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:26.863]         }
[01:29:26.863]         else {
[01:29:26.863]             ...future.result["stdout"] <- base::list(NULL)
[01:29:26.863]         }
[01:29:26.863]         base::close(...future.stdout)
[01:29:26.863]         ...future.stdout <- NULL
[01:29:26.863]     }
[01:29:26.863]     ...future.result$conditions <- ...future.conditions
[01:29:26.863]     ...future.result$finished <- base::Sys.time()
[01:29:26.863]     ...future.result
[01:29:26.863] }
[01:29:26.867] assign_globals() ...
[01:29:26.867] List of 1
[01:29:26.867]  $ x: int [1:4] 0 1 2 3
[01:29:26.867]  - attr(*, "where")=List of 1
[01:29:26.867]   ..$ x:<environment: R_EmptyEnv> 
[01:29:26.867]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:26.867]  - attr(*, "resolved")= logi FALSE
[01:29:26.867]  - attr(*, "total_size")= num 64
[01:29:26.867]  - attr(*, "already-done")= logi TRUE
[01:29:26.871] - copied 'x' to environment
[01:29:26.871] assign_globals() ... done
[01:29:26.872] plan(): Setting new future strategy stack:
[01:29:26.872] List of future strategies:
[01:29:26.872] 1. sequential:
[01:29:26.872]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.872]    - tweaked: FALSE
[01:29:26.872]    - call: NULL
[01:29:26.872] plan(): nbrOfWorkers() = 1
[01:29:26.874] plan(): Setting new future strategy stack:
[01:29:26.874] List of future strategies:
[01:29:26.874] 1. sequential:
[01:29:26.874]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.874]    - tweaked: FALSE
[01:29:26.874]    - call: plan(strategy)
[01:29:26.874] plan(): nbrOfWorkers() = 1
[01:29:26.875] SequentialFuture started (and completed)
[01:29:26.875] - Launch lazy future ... done
[01:29:26.875] run() for 'SequentialFuture' ... done
[01:29:26.875] getGlobalsAndPackages() ...
[01:29:26.875] Searching for globals...
[01:29:26.877] - globals found: [3] '{', 'sample', 'x'
[01:29:26.877] Searching for globals ... DONE
[01:29:26.877] Resolving globals: FALSE
[01:29:26.877] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:26.878] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:26.878] - globals: [1] 'x'
[01:29:26.878] 
[01:29:26.878] getGlobalsAndPackages() ... DONE
[01:29:26.879] run() for 'Future' ...
[01:29:26.879] - state: 'created'
[01:29:26.879] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:26.879] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:26.880] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:26.880]   - Field: 'label'
[01:29:26.880]   - Field: 'local'
[01:29:26.880]   - Field: 'owner'
[01:29:26.880]   - Field: 'envir'
[01:29:26.881]   - Field: 'packages'
[01:29:26.881]   - Field: 'gc'
[01:29:26.881]   - Field: 'conditions'
[01:29:26.881]   - Field: 'expr'
[01:29:26.881]   - Field: 'uuid'
[01:29:26.881]   - Field: 'seed'
[01:29:26.882]   - Field: 'version'
[01:29:26.882]   - Field: 'result'
[01:29:26.882]   - Field: 'asynchronous'
[01:29:26.882]   - Field: 'calls'
[01:29:26.882]   - Field: 'globals'
[01:29:26.882]   - Field: 'stdout'
[01:29:26.883]   - Field: 'earlySignal'
[01:29:26.883]   - Field: 'lazy'
[01:29:26.883]   - Field: 'state'
[01:29:26.883] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:26.883] - Launch lazy future ...
[01:29:26.884] Packages needed by the future expression (n = 0): <none>
[01:29:26.884] Packages needed by future strategies (n = 0): <none>
[01:29:26.884] {
[01:29:26.884]     {
[01:29:26.884]         {
[01:29:26.884]             ...future.startTime <- base::Sys.time()
[01:29:26.884]             {
[01:29:26.884]                 {
[01:29:26.884]                   {
[01:29:26.884]                     {
[01:29:26.884]                       base::local({
[01:29:26.884]                         has_future <- base::requireNamespace("future", 
[01:29:26.884]                           quietly = TRUE)
[01:29:26.884]                         if (has_future) {
[01:29:26.884]                           ns <- base::getNamespace("future")
[01:29:26.884]                           version <- ns[[".package"]][["version"]]
[01:29:26.884]                           if (is.null(version)) 
[01:29:26.884]                             version <- utils::packageVersion("future")
[01:29:26.884]                         }
[01:29:26.884]                         else {
[01:29:26.884]                           version <- NULL
[01:29:26.884]                         }
[01:29:26.884]                         if (!has_future || version < "1.8.0") {
[01:29:26.884]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:26.884]                             "", base::R.version$version.string), 
[01:29:26.884]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:26.884]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:26.884]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:26.884]                               "release", "version")], collapse = " "), 
[01:29:26.884]                             hostname = base::Sys.info()[["nodename"]])
[01:29:26.884]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:26.884]                             info)
[01:29:26.884]                           info <- base::paste(info, collapse = "; ")
[01:29:26.884]                           if (!has_future) {
[01:29:26.884]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:26.884]                               info)
[01:29:26.884]                           }
[01:29:26.884]                           else {
[01:29:26.884]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:26.884]                               info, version)
[01:29:26.884]                           }
[01:29:26.884]                           base::stop(msg)
[01:29:26.884]                         }
[01:29:26.884]                       })
[01:29:26.884]                     }
[01:29:26.884]                     options(future.plan = NULL)
[01:29:26.884]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.884]                     future::plan("default", .cleanup = FALSE, 
[01:29:26.884]                       .init = FALSE)
[01:29:26.884]                   }
[01:29:26.884]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[01:29:26.884]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[01:29:26.884]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[01:29:26.884]                 }
[01:29:26.884]                 ...future.workdir <- getwd()
[01:29:26.884]             }
[01:29:26.884]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:26.884]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:26.884]         }
[01:29:26.884]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:26.884]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:26.884]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:26.884]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:26.884]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:26.884]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:26.884]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:26.884]             base::names(...future.oldOptions))
[01:29:26.884]     }
[01:29:26.884]     if (FALSE) {
[01:29:26.884]     }
[01:29:26.884]     else {
[01:29:26.884]         if (TRUE) {
[01:29:26.884]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:26.884]                 open = "w")
[01:29:26.884]         }
[01:29:26.884]         else {
[01:29:26.884]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:26.884]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:26.884]         }
[01:29:26.884]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:26.884]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:26.884]             base::sink(type = "output", split = FALSE)
[01:29:26.884]             base::close(...future.stdout)
[01:29:26.884]         }, add = TRUE)
[01:29:26.884]     }
[01:29:26.884]     ...future.frame <- base::sys.nframe()
[01:29:26.884]     ...future.conditions <- base::list()
[01:29:26.884]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:26.884]     if (FALSE) {
[01:29:26.884]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:26.884]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:26.884]     }
[01:29:26.884]     ...future.result <- base::tryCatch({
[01:29:26.884]         base::withCallingHandlers({
[01:29:26.884]             ...future.value <- base::withVisible(base::local({
[01:29:26.884]                 sample(x, size = 1L)
[01:29:26.884]             }))
[01:29:26.884]             future::FutureResult(value = ...future.value$value, 
[01:29:26.884]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.884]                   ...future.rng), globalenv = if (FALSE) 
[01:29:26.884]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:26.884]                     ...future.globalenv.names))
[01:29:26.884]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:26.884]         }, condition = base::local({
[01:29:26.884]             c <- base::c
[01:29:26.884]             inherits <- base::inherits
[01:29:26.884]             invokeRestart <- base::invokeRestart
[01:29:26.884]             length <- base::length
[01:29:26.884]             list <- base::list
[01:29:26.884]             seq.int <- base::seq.int
[01:29:26.884]             signalCondition <- base::signalCondition
[01:29:26.884]             sys.calls <- base::sys.calls
[01:29:26.884]             `[[` <- base::`[[`
[01:29:26.884]             `+` <- base::`+`
[01:29:26.884]             `<<-` <- base::`<<-`
[01:29:26.884]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:26.884]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:26.884]                   3L)]
[01:29:26.884]             }
[01:29:26.884]             function(cond) {
[01:29:26.884]                 is_error <- inherits(cond, "error")
[01:29:26.884]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:26.884]                   NULL)
[01:29:26.884]                 if (is_error) {
[01:29:26.884]                   sessionInformation <- function() {
[01:29:26.884]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:26.884]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:26.884]                       search = base::search(), system = base::Sys.info())
[01:29:26.884]                   }
[01:29:26.884]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.884]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:26.884]                     cond$call), session = sessionInformation(), 
[01:29:26.884]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:26.884]                   signalCondition(cond)
[01:29:26.884]                 }
[01:29:26.884]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:26.884]                 "immediateCondition"))) {
[01:29:26.884]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:26.884]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.884]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:26.884]                   if (TRUE && !signal) {
[01:29:26.884]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.884]                     {
[01:29:26.884]                       inherits <- base::inherits
[01:29:26.884]                       invokeRestart <- base::invokeRestart
[01:29:26.884]                       is.null <- base::is.null
[01:29:26.884]                       muffled <- FALSE
[01:29:26.884]                       if (inherits(cond, "message")) {
[01:29:26.884]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.884]                         if (muffled) 
[01:29:26.884]                           invokeRestart("muffleMessage")
[01:29:26.884]                       }
[01:29:26.884]                       else if (inherits(cond, "warning")) {
[01:29:26.884]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.884]                         if (muffled) 
[01:29:26.884]                           invokeRestart("muffleWarning")
[01:29:26.884]                       }
[01:29:26.884]                       else if (inherits(cond, "condition")) {
[01:29:26.884]                         if (!is.null(pattern)) {
[01:29:26.884]                           computeRestarts <- base::computeRestarts
[01:29:26.884]                           grepl <- base::grepl
[01:29:26.884]                           restarts <- computeRestarts(cond)
[01:29:26.884]                           for (restart in restarts) {
[01:29:26.884]                             name <- restart$name
[01:29:26.884]                             if (is.null(name)) 
[01:29:26.884]                               next
[01:29:26.884]                             if (!grepl(pattern, name)) 
[01:29:26.884]                               next
[01:29:26.884]                             invokeRestart(restart)
[01:29:26.884]                             muffled <- TRUE
[01:29:26.884]                             break
[01:29:26.884]                           }
[01:29:26.884]                         }
[01:29:26.884]                       }
[01:29:26.884]                       invisible(muffled)
[01:29:26.884]                     }
[01:29:26.884]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.884]                   }
[01:29:26.884]                 }
[01:29:26.884]                 else {
[01:29:26.884]                   if (TRUE) {
[01:29:26.884]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.884]                     {
[01:29:26.884]                       inherits <- base::inherits
[01:29:26.884]                       invokeRestart <- base::invokeRestart
[01:29:26.884]                       is.null <- base::is.null
[01:29:26.884]                       muffled <- FALSE
[01:29:26.884]                       if (inherits(cond, "message")) {
[01:29:26.884]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.884]                         if (muffled) 
[01:29:26.884]                           invokeRestart("muffleMessage")
[01:29:26.884]                       }
[01:29:26.884]                       else if (inherits(cond, "warning")) {
[01:29:26.884]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.884]                         if (muffled) 
[01:29:26.884]                           invokeRestart("muffleWarning")
[01:29:26.884]                       }
[01:29:26.884]                       else if (inherits(cond, "condition")) {
[01:29:26.884]                         if (!is.null(pattern)) {
[01:29:26.884]                           computeRestarts <- base::computeRestarts
[01:29:26.884]                           grepl <- base::grepl
[01:29:26.884]                           restarts <- computeRestarts(cond)
[01:29:26.884]                           for (restart in restarts) {
[01:29:26.884]                             name <- restart$name
[01:29:26.884]                             if (is.null(name)) 
[01:29:26.884]                               next
[01:29:26.884]                             if (!grepl(pattern, name)) 
[01:29:26.884]                               next
[01:29:26.884]                             invokeRestart(restart)
[01:29:26.884]                             muffled <- TRUE
[01:29:26.884]                             break
[01:29:26.884]                           }
[01:29:26.884]                         }
[01:29:26.884]                       }
[01:29:26.884]                       invisible(muffled)
[01:29:26.884]                     }
[01:29:26.884]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.884]                   }
[01:29:26.884]                 }
[01:29:26.884]             }
[01:29:26.884]         }))
[01:29:26.884]     }, error = function(ex) {
[01:29:26.884]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:26.884]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.884]                 ...future.rng), started = ...future.startTime, 
[01:29:26.884]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:26.884]             version = "1.8"), class = "FutureResult")
[01:29:26.884]     }, finally = {
[01:29:26.884]         if (!identical(...future.workdir, getwd())) 
[01:29:26.884]             setwd(...future.workdir)
[01:29:26.884]         {
[01:29:26.884]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:26.884]                 ...future.oldOptions$nwarnings <- NULL
[01:29:26.884]             }
[01:29:26.884]             base::options(...future.oldOptions)
[01:29:26.884]             if (.Platform$OS.type == "windows") {
[01:29:26.884]                 old_names <- names(...future.oldEnvVars)
[01:29:26.884]                 envs <- base::Sys.getenv()
[01:29:26.884]                 names <- names(envs)
[01:29:26.884]                 common <- intersect(names, old_names)
[01:29:26.884]                 added <- setdiff(names, old_names)
[01:29:26.884]                 removed <- setdiff(old_names, names)
[01:29:26.884]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:26.884]                   envs[common]]
[01:29:26.884]                 NAMES <- toupper(changed)
[01:29:26.884]                 args <- list()
[01:29:26.884]                 for (kk in seq_along(NAMES)) {
[01:29:26.884]                   name <- changed[[kk]]
[01:29:26.884]                   NAME <- NAMES[[kk]]
[01:29:26.884]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.884]                     next
[01:29:26.884]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.884]                 }
[01:29:26.884]                 NAMES <- toupper(added)
[01:29:26.884]                 for (kk in seq_along(NAMES)) {
[01:29:26.884]                   name <- added[[kk]]
[01:29:26.884]                   NAME <- NAMES[[kk]]
[01:29:26.884]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.884]                     next
[01:29:26.884]                   args[[name]] <- ""
[01:29:26.884]                 }
[01:29:26.884]                 NAMES <- toupper(removed)
[01:29:26.884]                 for (kk in seq_along(NAMES)) {
[01:29:26.884]                   name <- removed[[kk]]
[01:29:26.884]                   NAME <- NAMES[[kk]]
[01:29:26.884]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.884]                     next
[01:29:26.884]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.884]                 }
[01:29:26.884]                 if (length(args) > 0) 
[01:29:26.884]                   base::do.call(base::Sys.setenv, args = args)
[01:29:26.884]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:26.884]             }
[01:29:26.884]             else {
[01:29:26.884]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:26.884]             }
[01:29:26.884]             {
[01:29:26.884]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:26.884]                   0L) {
[01:29:26.884]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:26.884]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:26.884]                   base::options(opts)
[01:29:26.884]                 }
[01:29:26.884]                 {
[01:29:26.884]                   {
[01:29:26.884]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:26.884]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:26.884]                     -1344458670L), envir = base::globalenv(), 
[01:29:26.884]                       inherits = FALSE)
[01:29:26.884]                     NULL
[01:29:26.884]                   }
[01:29:26.884]                   options(future.plan = NULL)
[01:29:26.884]                   if (is.na(NA_character_)) 
[01:29:26.884]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.884]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:26.884]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:26.884]                   {
[01:29:26.884]                     future <- SequentialFuture(..., envir = envir)
[01:29:26.884]                     if (!future$lazy) 
[01:29:26.884]                       future <- run(future)
[01:29:26.884]                     invisible(future)
[01:29:26.884]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:26.884]                 }
[01:29:26.884]             }
[01:29:26.884]         }
[01:29:26.884]     })
[01:29:26.884]     if (TRUE) {
[01:29:26.884]         base::sink(type = "output", split = FALSE)
[01:29:26.884]         if (TRUE) {
[01:29:26.884]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:26.884]         }
[01:29:26.884]         else {
[01:29:26.884]             ...future.result["stdout"] <- base::list(NULL)
[01:29:26.884]         }
[01:29:26.884]         base::close(...future.stdout)
[01:29:26.884]         ...future.stdout <- NULL
[01:29:26.884]     }
[01:29:26.884]     ...future.result$conditions <- ...future.conditions
[01:29:26.884]     ...future.result$finished <- base::Sys.time()
[01:29:26.884]     ...future.result
[01:29:26.884] }
[01:29:26.888] assign_globals() ...
[01:29:26.888] List of 1
[01:29:26.888]  $ x: int [1:4] 0 1 2 3
[01:29:26.888]  - attr(*, "where")=List of 1
[01:29:26.888]   ..$ x:<environment: R_EmptyEnv> 
[01:29:26.888]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:26.888]  - attr(*, "resolved")= logi FALSE
[01:29:26.888]  - attr(*, "total_size")= num 64
[01:29:26.888]  - attr(*, "already-done")= logi TRUE
[01:29:26.891] - copied 'x' to environment
[01:29:26.891] assign_globals() ... done
[01:29:26.892] plan(): Setting new future strategy stack:
[01:29:26.892] List of future strategies:
[01:29:26.892] 1. sequential:
[01:29:26.892]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.892]    - tweaked: FALSE
[01:29:26.892]    - call: NULL
[01:29:26.893] plan(): nbrOfWorkers() = 1
[01:29:26.894] plan(): Setting new future strategy stack:
[01:29:26.894] List of future strategies:
[01:29:26.894] 1. sequential:
[01:29:26.894]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.894]    - tweaked: FALSE
[01:29:26.894]    - call: plan(strategy)
[01:29:26.895] plan(): nbrOfWorkers() = 1
[01:29:26.895] SequentialFuture started (and completed)
[01:29:26.895] - Launch lazy future ... done
[01:29:26.895] run() for 'SequentialFuture' ... done
[01:29:26.895] getGlobalsAndPackages() ...
[01:29:26.896] Searching for globals...
[01:29:26.897] - globals found: [3] '{', 'sample', 'x'
[01:29:26.897] Searching for globals ... DONE
[01:29:26.897] Resolving globals: FALSE
[01:29:26.898] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:26.898] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:26.898] - globals: [1] 'x'
[01:29:26.898] 
[01:29:26.899] getGlobalsAndPackages() ... DONE
[01:29:26.899] run() for 'Future' ...
[01:29:26.899] - state: 'created'
[01:29:26.899] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:26.900] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:26.900] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:26.900]   - Field: 'label'
[01:29:26.900]   - Field: 'local'
[01:29:26.900]   - Field: 'owner'
[01:29:26.901]   - Field: 'envir'
[01:29:26.901]   - Field: 'packages'
[01:29:26.901]   - Field: 'gc'
[01:29:26.901]   - Field: 'conditions'
[01:29:26.901]   - Field: 'expr'
[01:29:26.902]   - Field: 'uuid'
[01:29:26.902]   - Field: 'seed'
[01:29:26.902]   - Field: 'version'
[01:29:26.903]   - Field: 'result'
[01:29:26.903]   - Field: 'asynchronous'
[01:29:26.903]   - Field: 'calls'
[01:29:26.904]   - Field: 'globals'
[01:29:26.904]   - Field: 'stdout'
[01:29:26.904]   - Field: 'earlySignal'
[01:29:26.904]   - Field: 'lazy'
[01:29:26.904]   - Field: 'state'
[01:29:26.905] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:26.905] - Launch lazy future ...
[01:29:26.905] Packages needed by the future expression (n = 0): <none>
[01:29:26.905] Packages needed by future strategies (n = 0): <none>
[01:29:26.906] {
[01:29:26.906]     {
[01:29:26.906]         {
[01:29:26.906]             ...future.startTime <- base::Sys.time()
[01:29:26.906]             {
[01:29:26.906]                 {
[01:29:26.906]                   {
[01:29:26.906]                     {
[01:29:26.906]                       base::local({
[01:29:26.906]                         has_future <- base::requireNamespace("future", 
[01:29:26.906]                           quietly = TRUE)
[01:29:26.906]                         if (has_future) {
[01:29:26.906]                           ns <- base::getNamespace("future")
[01:29:26.906]                           version <- ns[[".package"]][["version"]]
[01:29:26.906]                           if (is.null(version)) 
[01:29:26.906]                             version <- utils::packageVersion("future")
[01:29:26.906]                         }
[01:29:26.906]                         else {
[01:29:26.906]                           version <- NULL
[01:29:26.906]                         }
[01:29:26.906]                         if (!has_future || version < "1.8.0") {
[01:29:26.906]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:26.906]                             "", base::R.version$version.string), 
[01:29:26.906]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:26.906]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:26.906]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:26.906]                               "release", "version")], collapse = " "), 
[01:29:26.906]                             hostname = base::Sys.info()[["nodename"]])
[01:29:26.906]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:26.906]                             info)
[01:29:26.906]                           info <- base::paste(info, collapse = "; ")
[01:29:26.906]                           if (!has_future) {
[01:29:26.906]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:26.906]                               info)
[01:29:26.906]                           }
[01:29:26.906]                           else {
[01:29:26.906]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:26.906]                               info, version)
[01:29:26.906]                           }
[01:29:26.906]                           base::stop(msg)
[01:29:26.906]                         }
[01:29:26.906]                       })
[01:29:26.906]                     }
[01:29:26.906]                     options(future.plan = NULL)
[01:29:26.906]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.906]                     future::plan("default", .cleanup = FALSE, 
[01:29:26.906]                       .init = FALSE)
[01:29:26.906]                   }
[01:29:26.906]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[01:29:26.906]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[01:29:26.906]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[01:29:26.906]                 }
[01:29:26.906]                 ...future.workdir <- getwd()
[01:29:26.906]             }
[01:29:26.906]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:26.906]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:26.906]         }
[01:29:26.906]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:26.906]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:26.906]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:26.906]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:26.906]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:26.906]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:26.906]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:26.906]             base::names(...future.oldOptions))
[01:29:26.906]     }
[01:29:26.906]     if (FALSE) {
[01:29:26.906]     }
[01:29:26.906]     else {
[01:29:26.906]         if (TRUE) {
[01:29:26.906]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:26.906]                 open = "w")
[01:29:26.906]         }
[01:29:26.906]         else {
[01:29:26.906]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:26.906]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:26.906]         }
[01:29:26.906]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:26.906]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:26.906]             base::sink(type = "output", split = FALSE)
[01:29:26.906]             base::close(...future.stdout)
[01:29:26.906]         }, add = TRUE)
[01:29:26.906]     }
[01:29:26.906]     ...future.frame <- base::sys.nframe()
[01:29:26.906]     ...future.conditions <- base::list()
[01:29:26.906]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:26.906]     if (FALSE) {
[01:29:26.906]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:26.906]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:26.906]     }
[01:29:26.906]     ...future.result <- base::tryCatch({
[01:29:26.906]         base::withCallingHandlers({
[01:29:26.906]             ...future.value <- base::withVisible(base::local({
[01:29:26.906]                 sample(x, size = 1L)
[01:29:26.906]             }))
[01:29:26.906]             future::FutureResult(value = ...future.value$value, 
[01:29:26.906]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.906]                   ...future.rng), globalenv = if (FALSE) 
[01:29:26.906]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:26.906]                     ...future.globalenv.names))
[01:29:26.906]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:26.906]         }, condition = base::local({
[01:29:26.906]             c <- base::c
[01:29:26.906]             inherits <- base::inherits
[01:29:26.906]             invokeRestart <- base::invokeRestart
[01:29:26.906]             length <- base::length
[01:29:26.906]             list <- base::list
[01:29:26.906]             seq.int <- base::seq.int
[01:29:26.906]             signalCondition <- base::signalCondition
[01:29:26.906]             sys.calls <- base::sys.calls
[01:29:26.906]             `[[` <- base::`[[`
[01:29:26.906]             `+` <- base::`+`
[01:29:26.906]             `<<-` <- base::`<<-`
[01:29:26.906]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:26.906]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:26.906]                   3L)]
[01:29:26.906]             }
[01:29:26.906]             function(cond) {
[01:29:26.906]                 is_error <- inherits(cond, "error")
[01:29:26.906]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:26.906]                   NULL)
[01:29:26.906]                 if (is_error) {
[01:29:26.906]                   sessionInformation <- function() {
[01:29:26.906]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:26.906]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:26.906]                       search = base::search(), system = base::Sys.info())
[01:29:26.906]                   }
[01:29:26.906]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.906]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:26.906]                     cond$call), session = sessionInformation(), 
[01:29:26.906]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:26.906]                   signalCondition(cond)
[01:29:26.906]                 }
[01:29:26.906]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:26.906]                 "immediateCondition"))) {
[01:29:26.906]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:26.906]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.906]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:26.906]                   if (TRUE && !signal) {
[01:29:26.906]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.906]                     {
[01:29:26.906]                       inherits <- base::inherits
[01:29:26.906]                       invokeRestart <- base::invokeRestart
[01:29:26.906]                       is.null <- base::is.null
[01:29:26.906]                       muffled <- FALSE
[01:29:26.906]                       if (inherits(cond, "message")) {
[01:29:26.906]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.906]                         if (muffled) 
[01:29:26.906]                           invokeRestart("muffleMessage")
[01:29:26.906]                       }
[01:29:26.906]                       else if (inherits(cond, "warning")) {
[01:29:26.906]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.906]                         if (muffled) 
[01:29:26.906]                           invokeRestart("muffleWarning")
[01:29:26.906]                       }
[01:29:26.906]                       else if (inherits(cond, "condition")) {
[01:29:26.906]                         if (!is.null(pattern)) {
[01:29:26.906]                           computeRestarts <- base::computeRestarts
[01:29:26.906]                           grepl <- base::grepl
[01:29:26.906]                           restarts <- computeRestarts(cond)
[01:29:26.906]                           for (restart in restarts) {
[01:29:26.906]                             name <- restart$name
[01:29:26.906]                             if (is.null(name)) 
[01:29:26.906]                               next
[01:29:26.906]                             if (!grepl(pattern, name)) 
[01:29:26.906]                               next
[01:29:26.906]                             invokeRestart(restart)
[01:29:26.906]                             muffled <- TRUE
[01:29:26.906]                             break
[01:29:26.906]                           }
[01:29:26.906]                         }
[01:29:26.906]                       }
[01:29:26.906]                       invisible(muffled)
[01:29:26.906]                     }
[01:29:26.906]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.906]                   }
[01:29:26.906]                 }
[01:29:26.906]                 else {
[01:29:26.906]                   if (TRUE) {
[01:29:26.906]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.906]                     {
[01:29:26.906]                       inherits <- base::inherits
[01:29:26.906]                       invokeRestart <- base::invokeRestart
[01:29:26.906]                       is.null <- base::is.null
[01:29:26.906]                       muffled <- FALSE
[01:29:26.906]                       if (inherits(cond, "message")) {
[01:29:26.906]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.906]                         if (muffled) 
[01:29:26.906]                           invokeRestart("muffleMessage")
[01:29:26.906]                       }
[01:29:26.906]                       else if (inherits(cond, "warning")) {
[01:29:26.906]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.906]                         if (muffled) 
[01:29:26.906]                           invokeRestart("muffleWarning")
[01:29:26.906]                       }
[01:29:26.906]                       else if (inherits(cond, "condition")) {
[01:29:26.906]                         if (!is.null(pattern)) {
[01:29:26.906]                           computeRestarts <- base::computeRestarts
[01:29:26.906]                           grepl <- base::grepl
[01:29:26.906]                           restarts <- computeRestarts(cond)
[01:29:26.906]                           for (restart in restarts) {
[01:29:26.906]                             name <- restart$name
[01:29:26.906]                             if (is.null(name)) 
[01:29:26.906]                               next
[01:29:26.906]                             if (!grepl(pattern, name)) 
[01:29:26.906]                               next
[01:29:26.906]                             invokeRestart(restart)
[01:29:26.906]                             muffled <- TRUE
[01:29:26.906]                             break
[01:29:26.906]                           }
[01:29:26.906]                         }
[01:29:26.906]                       }
[01:29:26.906]                       invisible(muffled)
[01:29:26.906]                     }
[01:29:26.906]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.906]                   }
[01:29:26.906]                 }
[01:29:26.906]             }
[01:29:26.906]         }))
[01:29:26.906]     }, error = function(ex) {
[01:29:26.906]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:26.906]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.906]                 ...future.rng), started = ...future.startTime, 
[01:29:26.906]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:26.906]             version = "1.8"), class = "FutureResult")
[01:29:26.906]     }, finally = {
[01:29:26.906]         if (!identical(...future.workdir, getwd())) 
[01:29:26.906]             setwd(...future.workdir)
[01:29:26.906]         {
[01:29:26.906]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:26.906]                 ...future.oldOptions$nwarnings <- NULL
[01:29:26.906]             }
[01:29:26.906]             base::options(...future.oldOptions)
[01:29:26.906]             if (.Platform$OS.type == "windows") {
[01:29:26.906]                 old_names <- names(...future.oldEnvVars)
[01:29:26.906]                 envs <- base::Sys.getenv()
[01:29:26.906]                 names <- names(envs)
[01:29:26.906]                 common <- intersect(names, old_names)
[01:29:26.906]                 added <- setdiff(names, old_names)
[01:29:26.906]                 removed <- setdiff(old_names, names)
[01:29:26.906]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:26.906]                   envs[common]]
[01:29:26.906]                 NAMES <- toupper(changed)
[01:29:26.906]                 args <- list()
[01:29:26.906]                 for (kk in seq_along(NAMES)) {
[01:29:26.906]                   name <- changed[[kk]]
[01:29:26.906]                   NAME <- NAMES[[kk]]
[01:29:26.906]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.906]                     next
[01:29:26.906]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.906]                 }
[01:29:26.906]                 NAMES <- toupper(added)
[01:29:26.906]                 for (kk in seq_along(NAMES)) {
[01:29:26.906]                   name <- added[[kk]]
[01:29:26.906]                   NAME <- NAMES[[kk]]
[01:29:26.906]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.906]                     next
[01:29:26.906]                   args[[name]] <- ""
[01:29:26.906]                 }
[01:29:26.906]                 NAMES <- toupper(removed)
[01:29:26.906]                 for (kk in seq_along(NAMES)) {
[01:29:26.906]                   name <- removed[[kk]]
[01:29:26.906]                   NAME <- NAMES[[kk]]
[01:29:26.906]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.906]                     next
[01:29:26.906]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.906]                 }
[01:29:26.906]                 if (length(args) > 0) 
[01:29:26.906]                   base::do.call(base::Sys.setenv, args = args)
[01:29:26.906]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:26.906]             }
[01:29:26.906]             else {
[01:29:26.906]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:26.906]             }
[01:29:26.906]             {
[01:29:26.906]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:26.906]                   0L) {
[01:29:26.906]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:26.906]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:26.906]                   base::options(opts)
[01:29:26.906]                 }
[01:29:26.906]                 {
[01:29:26.906]                   {
[01:29:26.906]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:26.906]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:26.906]                     -1344458670L), envir = base::globalenv(), 
[01:29:26.906]                       inherits = FALSE)
[01:29:26.906]                     NULL
[01:29:26.906]                   }
[01:29:26.906]                   options(future.plan = NULL)
[01:29:26.906]                   if (is.na(NA_character_)) 
[01:29:26.906]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.906]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:26.906]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:26.906]                   {
[01:29:26.906]                     future <- SequentialFuture(..., envir = envir)
[01:29:26.906]                     if (!future$lazy) 
[01:29:26.906]                       future <- run(future)
[01:29:26.906]                     invisible(future)
[01:29:26.906]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:26.906]                 }
[01:29:26.906]             }
[01:29:26.906]         }
[01:29:26.906]     })
[01:29:26.906]     if (TRUE) {
[01:29:26.906]         base::sink(type = "output", split = FALSE)
[01:29:26.906]         if (TRUE) {
[01:29:26.906]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:26.906]         }
[01:29:26.906]         else {
[01:29:26.906]             ...future.result["stdout"] <- base::list(NULL)
[01:29:26.906]         }
[01:29:26.906]         base::close(...future.stdout)
[01:29:26.906]         ...future.stdout <- NULL
[01:29:26.906]     }
[01:29:26.906]     ...future.result$conditions <- ...future.conditions
[01:29:26.906]     ...future.result$finished <- base::Sys.time()
[01:29:26.906]     ...future.result
[01:29:26.906] }
[01:29:26.910] assign_globals() ...
[01:29:26.910] List of 1
[01:29:26.910]  $ x: int [1:4] 0 1 2 3
[01:29:26.910]  - attr(*, "where")=List of 1
[01:29:26.910]   ..$ x:<environment: R_EmptyEnv> 
[01:29:26.910]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:26.910]  - attr(*, "resolved")= logi FALSE
[01:29:26.910]  - attr(*, "total_size")= num 64
[01:29:26.910]  - attr(*, "already-done")= logi TRUE
[01:29:26.913] - copied 'x' to environment
[01:29:26.913] assign_globals() ... done
[01:29:26.914] plan(): Setting new future strategy stack:
[01:29:26.914] List of future strategies:
[01:29:26.914] 1. sequential:
[01:29:26.914]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.914]    - tweaked: FALSE
[01:29:26.914]    - call: NULL
[01:29:26.915] plan(): nbrOfWorkers() = 1
[01:29:26.916] plan(): Setting new future strategy stack:
[01:29:26.916] List of future strategies:
[01:29:26.916] 1. sequential:
[01:29:26.916]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.916]    - tweaked: FALSE
[01:29:26.916]    - call: plan(strategy)
[01:29:26.917] plan(): nbrOfWorkers() = 1
[01:29:26.917] SequentialFuture started (and completed)
[01:29:26.917] - Launch lazy future ... done
[01:29:26.917] run() for 'SequentialFuture' ... done
[01:29:26.917] getGlobalsAndPackages() ...
[01:29:26.918] Searching for globals...
[01:29:26.919] - globals found: [3] '{', 'sample', 'x'
[01:29:26.919] Searching for globals ... DONE
[01:29:26.919] Resolving globals: FALSE
[01:29:26.920] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:26.920] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:26.920] - globals: [1] 'x'
[01:29:26.920] 
[01:29:26.921] getGlobalsAndPackages() ... DONE
[01:29:26.921] run() for 'Future' ...
[01:29:26.921] - state: 'created'
[01:29:26.921] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:26.922] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:26.922] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:26.922]   - Field: 'label'
[01:29:26.922]   - Field: 'local'
[01:29:26.922]   - Field: 'owner'
[01:29:26.923]   - Field: 'envir'
[01:29:26.923]   - Field: 'packages'
[01:29:26.923]   - Field: 'gc'
[01:29:26.923]   - Field: 'conditions'
[01:29:26.923]   - Field: 'expr'
[01:29:26.923]   - Field: 'uuid'
[01:29:26.924]   - Field: 'seed'
[01:29:26.924]   - Field: 'version'
[01:29:26.924]   - Field: 'result'
[01:29:26.924]   - Field: 'asynchronous'
[01:29:26.924]   - Field: 'calls'
[01:29:26.925]   - Field: 'globals'
[01:29:26.925]   - Field: 'stdout'
[01:29:26.925]   - Field: 'earlySignal'
[01:29:26.925]   - Field: 'lazy'
[01:29:26.925]   - Field: 'state'
[01:29:26.925] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:26.926] - Launch lazy future ...
[01:29:26.926] Packages needed by the future expression (n = 0): <none>
[01:29:26.926] Packages needed by future strategies (n = 0): <none>
[01:29:26.927] {
[01:29:26.927]     {
[01:29:26.927]         {
[01:29:26.927]             ...future.startTime <- base::Sys.time()
[01:29:26.927]             {
[01:29:26.927]                 {
[01:29:26.927]                   {
[01:29:26.927]                     {
[01:29:26.927]                       base::local({
[01:29:26.927]                         has_future <- base::requireNamespace("future", 
[01:29:26.927]                           quietly = TRUE)
[01:29:26.927]                         if (has_future) {
[01:29:26.927]                           ns <- base::getNamespace("future")
[01:29:26.927]                           version <- ns[[".package"]][["version"]]
[01:29:26.927]                           if (is.null(version)) 
[01:29:26.927]                             version <- utils::packageVersion("future")
[01:29:26.927]                         }
[01:29:26.927]                         else {
[01:29:26.927]                           version <- NULL
[01:29:26.927]                         }
[01:29:26.927]                         if (!has_future || version < "1.8.0") {
[01:29:26.927]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:26.927]                             "", base::R.version$version.string), 
[01:29:26.927]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:26.927]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:26.927]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:26.927]                               "release", "version")], collapse = " "), 
[01:29:26.927]                             hostname = base::Sys.info()[["nodename"]])
[01:29:26.927]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:26.927]                             info)
[01:29:26.927]                           info <- base::paste(info, collapse = "; ")
[01:29:26.927]                           if (!has_future) {
[01:29:26.927]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:26.927]                               info)
[01:29:26.927]                           }
[01:29:26.927]                           else {
[01:29:26.927]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:26.927]                               info, version)
[01:29:26.927]                           }
[01:29:26.927]                           base::stop(msg)
[01:29:26.927]                         }
[01:29:26.927]                       })
[01:29:26.927]                     }
[01:29:26.927]                     options(future.plan = NULL)
[01:29:26.927]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.927]                     future::plan("default", .cleanup = FALSE, 
[01:29:26.927]                       .init = FALSE)
[01:29:26.927]                   }
[01:29:26.927]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[01:29:26.927]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[01:29:26.927]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[01:29:26.927]                 }
[01:29:26.927]                 ...future.workdir <- getwd()
[01:29:26.927]             }
[01:29:26.927]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:26.927]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:26.927]         }
[01:29:26.927]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:26.927]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:26.927]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:26.927]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:26.927]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:29:26.927]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:26.927]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:26.927]             base::names(...future.oldOptions))
[01:29:26.927]     }
[01:29:26.927]     if (FALSE) {
[01:29:26.927]     }
[01:29:26.927]     else {
[01:29:26.927]         if (TRUE) {
[01:29:26.927]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:26.927]                 open = "w")
[01:29:26.927]         }
[01:29:26.927]         else {
[01:29:26.927]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:26.927]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:26.927]         }
[01:29:26.927]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:26.927]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:26.927]             base::sink(type = "output", split = FALSE)
[01:29:26.927]             base::close(...future.stdout)
[01:29:26.927]         }, add = TRUE)
[01:29:26.927]     }
[01:29:26.927]     ...future.frame <- base::sys.nframe()
[01:29:26.927]     ...future.conditions <- base::list()
[01:29:26.927]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:26.927]     if (FALSE) {
[01:29:26.927]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:26.927]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:26.927]     }
[01:29:26.927]     ...future.result <- base::tryCatch({
[01:29:26.927]         base::withCallingHandlers({
[01:29:26.927]             ...future.value <- base::withVisible(base::local({
[01:29:26.927]                 sample(x, size = 1L)
[01:29:26.927]             }))
[01:29:26.927]             future::FutureResult(value = ...future.value$value, 
[01:29:26.927]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.927]                   ...future.rng), globalenv = if (FALSE) 
[01:29:26.927]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:26.927]                     ...future.globalenv.names))
[01:29:26.927]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:26.927]         }, condition = base::local({
[01:29:26.927]             c <- base::c
[01:29:26.927]             inherits <- base::inherits
[01:29:26.927]             invokeRestart <- base::invokeRestart
[01:29:26.927]             length <- base::length
[01:29:26.927]             list <- base::list
[01:29:26.927]             seq.int <- base::seq.int
[01:29:26.927]             signalCondition <- base::signalCondition
[01:29:26.927]             sys.calls <- base::sys.calls
[01:29:26.927]             `[[` <- base::`[[`
[01:29:26.927]             `+` <- base::`+`
[01:29:26.927]             `<<-` <- base::`<<-`
[01:29:26.927]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:26.927]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:26.927]                   3L)]
[01:29:26.927]             }
[01:29:26.927]             function(cond) {
[01:29:26.927]                 is_error <- inherits(cond, "error")
[01:29:26.927]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:26.927]                   NULL)
[01:29:26.927]                 if (is_error) {
[01:29:26.927]                   sessionInformation <- function() {
[01:29:26.927]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:26.927]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:26.927]                       search = base::search(), system = base::Sys.info())
[01:29:26.927]                   }
[01:29:26.927]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.927]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:26.927]                     cond$call), session = sessionInformation(), 
[01:29:26.927]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:26.927]                   signalCondition(cond)
[01:29:26.927]                 }
[01:29:26.927]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:26.927]                 "immediateCondition"))) {
[01:29:26.927]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:26.927]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.927]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:26.927]                   if (TRUE && !signal) {
[01:29:26.927]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.927]                     {
[01:29:26.927]                       inherits <- base::inherits
[01:29:26.927]                       invokeRestart <- base::invokeRestart
[01:29:26.927]                       is.null <- base::is.null
[01:29:26.927]                       muffled <- FALSE
[01:29:26.927]                       if (inherits(cond, "message")) {
[01:29:26.927]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.927]                         if (muffled) 
[01:29:26.927]                           invokeRestart("muffleMessage")
[01:29:26.927]                       }
[01:29:26.927]                       else if (inherits(cond, "warning")) {
[01:29:26.927]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.927]                         if (muffled) 
[01:29:26.927]                           invokeRestart("muffleWarning")
[01:29:26.927]                       }
[01:29:26.927]                       else if (inherits(cond, "condition")) {
[01:29:26.927]                         if (!is.null(pattern)) {
[01:29:26.927]                           computeRestarts <- base::computeRestarts
[01:29:26.927]                           grepl <- base::grepl
[01:29:26.927]                           restarts <- computeRestarts(cond)
[01:29:26.927]                           for (restart in restarts) {
[01:29:26.927]                             name <- restart$name
[01:29:26.927]                             if (is.null(name)) 
[01:29:26.927]                               next
[01:29:26.927]                             if (!grepl(pattern, name)) 
[01:29:26.927]                               next
[01:29:26.927]                             invokeRestart(restart)
[01:29:26.927]                             muffled <- TRUE
[01:29:26.927]                             break
[01:29:26.927]                           }
[01:29:26.927]                         }
[01:29:26.927]                       }
[01:29:26.927]                       invisible(muffled)
[01:29:26.927]                     }
[01:29:26.927]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.927]                   }
[01:29:26.927]                 }
[01:29:26.927]                 else {
[01:29:26.927]                   if (TRUE) {
[01:29:26.927]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.927]                     {
[01:29:26.927]                       inherits <- base::inherits
[01:29:26.927]                       invokeRestart <- base::invokeRestart
[01:29:26.927]                       is.null <- base::is.null
[01:29:26.927]                       muffled <- FALSE
[01:29:26.927]                       if (inherits(cond, "message")) {
[01:29:26.927]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.927]                         if (muffled) 
[01:29:26.927]                           invokeRestart("muffleMessage")
[01:29:26.927]                       }
[01:29:26.927]                       else if (inherits(cond, "warning")) {
[01:29:26.927]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.927]                         if (muffled) 
[01:29:26.927]                           invokeRestart("muffleWarning")
[01:29:26.927]                       }
[01:29:26.927]                       else if (inherits(cond, "condition")) {
[01:29:26.927]                         if (!is.null(pattern)) {
[01:29:26.927]                           computeRestarts <- base::computeRestarts
[01:29:26.927]                           grepl <- base::grepl
[01:29:26.927]                           restarts <- computeRestarts(cond)
[01:29:26.927]                           for (restart in restarts) {
[01:29:26.927]                             name <- restart$name
[01:29:26.927]                             if (is.null(name)) 
[01:29:26.927]                               next
[01:29:26.927]                             if (!grepl(pattern, name)) 
[01:29:26.927]                               next
[01:29:26.927]                             invokeRestart(restart)
[01:29:26.927]                             muffled <- TRUE
[01:29:26.927]                             break
[01:29:26.927]                           }
[01:29:26.927]                         }
[01:29:26.927]                       }
[01:29:26.927]                       invisible(muffled)
[01:29:26.927]                     }
[01:29:26.927]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.927]                   }
[01:29:26.927]                 }
[01:29:26.927]             }
[01:29:26.927]         }))
[01:29:26.927]     }, error = function(ex) {
[01:29:26.927]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:26.927]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.927]                 ...future.rng), started = ...future.startTime, 
[01:29:26.927]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:26.927]             version = "1.8"), class = "FutureResult")
[01:29:26.927]     }, finally = {
[01:29:26.927]         if (!identical(...future.workdir, getwd())) 
[01:29:26.927]             setwd(...future.workdir)
[01:29:26.927]         {
[01:29:26.927]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:26.927]                 ...future.oldOptions$nwarnings <- NULL
[01:29:26.927]             }
[01:29:26.927]             base::options(...future.oldOptions)
[01:29:26.927]             if (.Platform$OS.type == "windows") {
[01:29:26.927]                 old_names <- names(...future.oldEnvVars)
[01:29:26.927]                 envs <- base::Sys.getenv()
[01:29:26.927]                 names <- names(envs)
[01:29:26.927]                 common <- intersect(names, old_names)
[01:29:26.927]                 added <- setdiff(names, old_names)
[01:29:26.927]                 removed <- setdiff(old_names, names)
[01:29:26.927]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:26.927]                   envs[common]]
[01:29:26.927]                 NAMES <- toupper(changed)
[01:29:26.927]                 args <- list()
[01:29:26.927]                 for (kk in seq_along(NAMES)) {
[01:29:26.927]                   name <- changed[[kk]]
[01:29:26.927]                   NAME <- NAMES[[kk]]
[01:29:26.927]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.927]                     next
[01:29:26.927]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.927]                 }
[01:29:26.927]                 NAMES <- toupper(added)
[01:29:26.927]                 for (kk in seq_along(NAMES)) {
[01:29:26.927]                   name <- added[[kk]]
[01:29:26.927]                   NAME <- NAMES[[kk]]
[01:29:26.927]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.927]                     next
[01:29:26.927]                   args[[name]] <- ""
[01:29:26.927]                 }
[01:29:26.927]                 NAMES <- toupper(removed)
[01:29:26.927]                 for (kk in seq_along(NAMES)) {
[01:29:26.927]                   name <- removed[[kk]]
[01:29:26.927]                   NAME <- NAMES[[kk]]
[01:29:26.927]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.927]                     next
[01:29:26.927]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.927]                 }
[01:29:26.927]                 if (length(args) > 0) 
[01:29:26.927]                   base::do.call(base::Sys.setenv, args = args)
[01:29:26.927]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:26.927]             }
[01:29:26.927]             else {
[01:29:26.927]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:26.927]             }
[01:29:26.927]             {
[01:29:26.927]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:26.927]                   0L) {
[01:29:26.927]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:26.927]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:26.927]                   base::options(opts)
[01:29:26.927]                 }
[01:29:26.927]                 {
[01:29:26.927]                   {
[01:29:26.927]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:26.927]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:26.927]                     -1344458670L), envir = base::globalenv(), 
[01:29:26.927]                       inherits = FALSE)
[01:29:26.927]                     NULL
[01:29:26.927]                   }
[01:29:26.927]                   options(future.plan = NULL)
[01:29:26.927]                   if (is.na(NA_character_)) 
[01:29:26.927]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.927]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:26.927]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:26.927]                   {
[01:29:26.927]                     future <- SequentialFuture(..., envir = envir)
[01:29:26.927]                     if (!future$lazy) 
[01:29:26.927]                       future <- run(future)
[01:29:26.927]                     invisible(future)
[01:29:26.927]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:26.927]                 }
[01:29:26.927]             }
[01:29:26.927]         }
[01:29:26.927]     })
[01:29:26.927]     if (TRUE) {
[01:29:26.927]         base::sink(type = "output", split = FALSE)
[01:29:26.927]         if (TRUE) {
[01:29:26.927]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:26.927]         }
[01:29:26.927]         else {
[01:29:26.927]             ...future.result["stdout"] <- base::list(NULL)
[01:29:26.927]         }
[01:29:26.927]         base::close(...future.stdout)
[01:29:26.927]         ...future.stdout <- NULL
[01:29:26.927]     }
[01:29:26.927]     ...future.result$conditions <- ...future.conditions
[01:29:26.927]     ...future.result$finished <- base::Sys.time()
[01:29:26.927]     ...future.result
[01:29:26.927] }
[01:29:26.931] assign_globals() ...
[01:29:26.931] List of 1
[01:29:26.931]  $ x: int [1:4] 0 1 2 3
[01:29:26.931]  - attr(*, "where")=List of 1
[01:29:26.931]   ..$ x:<environment: R_EmptyEnv> 
[01:29:26.931]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:26.931]  - attr(*, "resolved")= logi FALSE
[01:29:26.931]  - attr(*, "total_size")= num 64
[01:29:26.931]  - attr(*, "already-done")= logi TRUE
[01:29:26.934] - copied 'x' to environment
[01:29:26.934] assign_globals() ... done
[01:29:26.934] plan(): Setting new future strategy stack:
[01:29:26.934] List of future strategies:
[01:29:26.934] 1. sequential:
[01:29:26.934]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.934]    - tweaked: FALSE
[01:29:26.934]    - call: NULL
[01:29:26.935] plan(): nbrOfWorkers() = 1
[01:29:26.936] plan(): Setting new future strategy stack:
[01:29:26.936] List of future strategies:
[01:29:26.936] 1. sequential:
[01:29:26.936]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.936]    - tweaked: FALSE
[01:29:26.936]    - call: plan(strategy)
[01:29:26.937] plan(): nbrOfWorkers() = 1
[01:29:26.937] SequentialFuture started (and completed)
[01:29:26.938] - Launch lazy future ... done
[01:29:26.938] run() for 'SequentialFuture' ... done
[01:29:26.938] resolve() on list ...
[01:29:26.938]  recursive: 0
[01:29:26.938]  length: 4
[01:29:26.938] 
[01:29:26.939] resolved() for 'SequentialFuture' ...
[01:29:26.940] - state: 'finished'
[01:29:26.940] - run: TRUE
[01:29:26.940] - result: 'FutureResult'
[01:29:26.941] resolved() for 'SequentialFuture' ... done
[01:29:26.941] Future #1
[01:29:26.941] signalConditionsASAP(SequentialFuture, pos=1) ...
[01:29:26.941] - nx: 4
[01:29:26.941] - relay: TRUE
[01:29:26.941] - stdout: TRUE
[01:29:26.942] - signal: TRUE
[01:29:26.942] - resignal: FALSE
[01:29:26.942] - force: TRUE
[01:29:26.942] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:26.942] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:26.942]  - until=1
[01:29:26.943]  - relaying element #1
[01:29:26.943] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:26.943] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:26.943] signalConditionsASAP(SequentialFuture, pos=1) ... done
[01:29:26.943]  length: 3 (resolved future 1)
[01:29:26.944] resolved() for 'SequentialFuture' ...
[01:29:26.944] - state: 'finished'
[01:29:26.944] - run: TRUE
[01:29:26.944] - result: 'FutureResult'
[01:29:26.944] resolved() for 'SequentialFuture' ... done
[01:29:26.945] Future #2
[01:29:26.945] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:29:26.945] - nx: 4
[01:29:26.945] - relay: TRUE
[01:29:26.945] - stdout: TRUE
[01:29:26.945] - signal: TRUE
[01:29:26.945] - resignal: FALSE
[01:29:26.946] - force: TRUE
[01:29:26.946] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:26.946] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:26.946]  - until=2
[01:29:26.946]  - relaying element #2
[01:29:26.947] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:26.947] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:26.947] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:29:26.947]  length: 2 (resolved future 2)
[01:29:26.947] resolved() for 'SequentialFuture' ...
[01:29:26.947] - state: 'finished'
[01:29:26.948] - run: TRUE
[01:29:26.948] - result: 'FutureResult'
[01:29:26.948] resolved() for 'SequentialFuture' ... done
[01:29:26.948] Future #3
[01:29:26.948] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:29:26.949] - nx: 4
[01:29:26.949] - relay: TRUE
[01:29:26.949] - stdout: TRUE
[01:29:26.949] - signal: TRUE
[01:29:26.949] - resignal: FALSE
[01:29:26.949] - force: TRUE
[01:29:26.949] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:26.950] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:26.950]  - until=3
[01:29:26.950]  - relaying element #3
[01:29:26.950] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:26.950] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:26.951] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:29:26.951]  length: 1 (resolved future 3)
[01:29:26.951] resolved() for 'SequentialFuture' ...
[01:29:26.951] - state: 'finished'
[01:29:26.951] - run: TRUE
[01:29:26.951] - result: 'FutureResult'
[01:29:26.952] resolved() for 'SequentialFuture' ... done
[01:29:26.952] Future #4
[01:29:26.952] signalConditionsASAP(SequentialFuture, pos=4) ...
[01:29:26.952] - nx: 4
[01:29:26.952] - relay: TRUE
[01:29:26.953] - stdout: TRUE
[01:29:26.953] - signal: TRUE
[01:29:26.953] - resignal: FALSE
[01:29:26.953] - force: TRUE
[01:29:26.953] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:26.953] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:26.953]  - until=4
[01:29:26.954]  - relaying element #4
[01:29:26.954] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:26.954] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:26.954] signalConditionsASAP(SequentialFuture, pos=4) ... done
[01:29:26.954]  length: 0 (resolved future 4)
[01:29:26.955] Relaying remaining futures
[01:29:26.955] signalConditionsASAP(NULL, pos=0) ...
[01:29:26.955] - nx: 4
[01:29:26.955] - relay: TRUE
[01:29:26.955] - stdout: TRUE
[01:29:26.955] - signal: TRUE
[01:29:26.956] - resignal: FALSE
[01:29:26.956] - force: TRUE
[01:29:26.956] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:26.956] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[01:29:26.956] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:26.956] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:26.957] signalConditionsASAP(NULL, pos=0) ... done
[01:29:26.957] resolve() on list ... DONE
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[01:29:26.958] getGlobalsAndPackages() ...
[01:29:26.958] Searching for globals...
[01:29:26.959] - globals found: [3] '{', 'sample', 'x'
[01:29:26.959] Searching for globals ... DONE
[01:29:26.959] Resolving globals: FALSE
[01:29:26.960] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:26.960] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:26.960] - globals: [1] 'x'
[01:29:26.961] 
[01:29:26.961] getGlobalsAndPackages() ... DONE
[01:29:26.961] run() for 'Future' ...
[01:29:26.961] - state: 'created'
[01:29:26.961] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:26.962] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:26.962] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:26.962]   - Field: 'label'
[01:29:26.962]   - Field: 'local'
[01:29:26.963]   - Field: 'owner'
[01:29:26.963]   - Field: 'envir'
[01:29:26.963]   - Field: 'packages'
[01:29:26.963]   - Field: 'gc'
[01:29:26.963]   - Field: 'conditions'
[01:29:26.963]   - Field: 'expr'
[01:29:26.964]   - Field: 'uuid'
[01:29:26.964]   - Field: 'seed'
[01:29:26.964]   - Field: 'version'
[01:29:26.964]   - Field: 'result'
[01:29:26.964]   - Field: 'asynchronous'
[01:29:26.964]   - Field: 'calls'
[01:29:26.965]   - Field: 'globals'
[01:29:26.965]   - Field: 'stdout'
[01:29:26.965]   - Field: 'earlySignal'
[01:29:26.965]   - Field: 'lazy'
[01:29:26.965]   - Field: 'state'
[01:29:26.966] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:26.966] - Launch lazy future ...
[01:29:26.966] Packages needed by the future expression (n = 0): <none>
[01:29:26.966] Packages needed by future strategies (n = 0): <none>
[01:29:26.967] {
[01:29:26.967]     {
[01:29:26.967]         {
[01:29:26.967]             ...future.startTime <- base::Sys.time()
[01:29:26.967]             {
[01:29:26.967]                 {
[01:29:26.967]                   {
[01:29:26.967]                     base::local({
[01:29:26.967]                       has_future <- base::requireNamespace("future", 
[01:29:26.967]                         quietly = TRUE)
[01:29:26.967]                       if (has_future) {
[01:29:26.967]                         ns <- base::getNamespace("future")
[01:29:26.967]                         version <- ns[[".package"]][["version"]]
[01:29:26.967]                         if (is.null(version)) 
[01:29:26.967]                           version <- utils::packageVersion("future")
[01:29:26.967]                       }
[01:29:26.967]                       else {
[01:29:26.967]                         version <- NULL
[01:29:26.967]                       }
[01:29:26.967]                       if (!has_future || version < "1.8.0") {
[01:29:26.967]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:26.967]                           "", base::R.version$version.string), 
[01:29:26.967]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:26.967]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:26.967]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:26.967]                             "release", "version")], collapse = " "), 
[01:29:26.967]                           hostname = base::Sys.info()[["nodename"]])
[01:29:26.967]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:26.967]                           info)
[01:29:26.967]                         info <- base::paste(info, collapse = "; ")
[01:29:26.967]                         if (!has_future) {
[01:29:26.967]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:26.967]                             info)
[01:29:26.967]                         }
[01:29:26.967]                         else {
[01:29:26.967]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:26.967]                             info, version)
[01:29:26.967]                         }
[01:29:26.967]                         base::stop(msg)
[01:29:26.967]                       }
[01:29:26.967]                     })
[01:29:26.967]                   }
[01:29:26.967]                   options(future.plan = NULL)
[01:29:26.967]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.967]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:26.967]                 }
[01:29:26.967]                 ...future.workdir <- getwd()
[01:29:26.967]             }
[01:29:26.967]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:26.967]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:26.967]         }
[01:29:26.967]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:26.967]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:26.967]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:26.967]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:26.967]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:26.967]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:26.967]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:26.967]             base::names(...future.oldOptions))
[01:29:26.967]     }
[01:29:26.967]     if (FALSE) {
[01:29:26.967]     }
[01:29:26.967]     else {
[01:29:26.967]         if (TRUE) {
[01:29:26.967]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:26.967]                 open = "w")
[01:29:26.967]         }
[01:29:26.967]         else {
[01:29:26.967]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:26.967]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:26.967]         }
[01:29:26.967]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:26.967]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:26.967]             base::sink(type = "output", split = FALSE)
[01:29:26.967]             base::close(...future.stdout)
[01:29:26.967]         }, add = TRUE)
[01:29:26.967]     }
[01:29:26.967]     ...future.frame <- base::sys.nframe()
[01:29:26.967]     ...future.conditions <- base::list()
[01:29:26.967]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:26.967]     if (FALSE) {
[01:29:26.967]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:26.967]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:26.967]     }
[01:29:26.967]     ...future.result <- base::tryCatch({
[01:29:26.967]         base::withCallingHandlers({
[01:29:26.967]             ...future.value <- base::withVisible(base::local({
[01:29:26.967]                 sample(x, size = 1L)
[01:29:26.967]             }))
[01:29:26.967]             future::FutureResult(value = ...future.value$value, 
[01:29:26.967]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.967]                   ...future.rng), globalenv = if (FALSE) 
[01:29:26.967]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:26.967]                     ...future.globalenv.names))
[01:29:26.967]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:26.967]         }, condition = base::local({
[01:29:26.967]             c <- base::c
[01:29:26.967]             inherits <- base::inherits
[01:29:26.967]             invokeRestart <- base::invokeRestart
[01:29:26.967]             length <- base::length
[01:29:26.967]             list <- base::list
[01:29:26.967]             seq.int <- base::seq.int
[01:29:26.967]             signalCondition <- base::signalCondition
[01:29:26.967]             sys.calls <- base::sys.calls
[01:29:26.967]             `[[` <- base::`[[`
[01:29:26.967]             `+` <- base::`+`
[01:29:26.967]             `<<-` <- base::`<<-`
[01:29:26.967]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:26.967]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:26.967]                   3L)]
[01:29:26.967]             }
[01:29:26.967]             function(cond) {
[01:29:26.967]                 is_error <- inherits(cond, "error")
[01:29:26.967]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:26.967]                   NULL)
[01:29:26.967]                 if (is_error) {
[01:29:26.967]                   sessionInformation <- function() {
[01:29:26.967]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:26.967]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:26.967]                       search = base::search(), system = base::Sys.info())
[01:29:26.967]                   }
[01:29:26.967]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.967]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:26.967]                     cond$call), session = sessionInformation(), 
[01:29:26.967]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:26.967]                   signalCondition(cond)
[01:29:26.967]                 }
[01:29:26.967]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:26.967]                 "immediateCondition"))) {
[01:29:26.967]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:26.967]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.967]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:26.967]                   if (TRUE && !signal) {
[01:29:26.967]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.967]                     {
[01:29:26.967]                       inherits <- base::inherits
[01:29:26.967]                       invokeRestart <- base::invokeRestart
[01:29:26.967]                       is.null <- base::is.null
[01:29:26.967]                       muffled <- FALSE
[01:29:26.967]                       if (inherits(cond, "message")) {
[01:29:26.967]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.967]                         if (muffled) 
[01:29:26.967]                           invokeRestart("muffleMessage")
[01:29:26.967]                       }
[01:29:26.967]                       else if (inherits(cond, "warning")) {
[01:29:26.967]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.967]                         if (muffled) 
[01:29:26.967]                           invokeRestart("muffleWarning")
[01:29:26.967]                       }
[01:29:26.967]                       else if (inherits(cond, "condition")) {
[01:29:26.967]                         if (!is.null(pattern)) {
[01:29:26.967]                           computeRestarts <- base::computeRestarts
[01:29:26.967]                           grepl <- base::grepl
[01:29:26.967]                           restarts <- computeRestarts(cond)
[01:29:26.967]                           for (restart in restarts) {
[01:29:26.967]                             name <- restart$name
[01:29:26.967]                             if (is.null(name)) 
[01:29:26.967]                               next
[01:29:26.967]                             if (!grepl(pattern, name)) 
[01:29:26.967]                               next
[01:29:26.967]                             invokeRestart(restart)
[01:29:26.967]                             muffled <- TRUE
[01:29:26.967]                             break
[01:29:26.967]                           }
[01:29:26.967]                         }
[01:29:26.967]                       }
[01:29:26.967]                       invisible(muffled)
[01:29:26.967]                     }
[01:29:26.967]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.967]                   }
[01:29:26.967]                 }
[01:29:26.967]                 else {
[01:29:26.967]                   if (TRUE) {
[01:29:26.967]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.967]                     {
[01:29:26.967]                       inherits <- base::inherits
[01:29:26.967]                       invokeRestart <- base::invokeRestart
[01:29:26.967]                       is.null <- base::is.null
[01:29:26.967]                       muffled <- FALSE
[01:29:26.967]                       if (inherits(cond, "message")) {
[01:29:26.967]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.967]                         if (muffled) 
[01:29:26.967]                           invokeRestart("muffleMessage")
[01:29:26.967]                       }
[01:29:26.967]                       else if (inherits(cond, "warning")) {
[01:29:26.967]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.967]                         if (muffled) 
[01:29:26.967]                           invokeRestart("muffleWarning")
[01:29:26.967]                       }
[01:29:26.967]                       else if (inherits(cond, "condition")) {
[01:29:26.967]                         if (!is.null(pattern)) {
[01:29:26.967]                           computeRestarts <- base::computeRestarts
[01:29:26.967]                           grepl <- base::grepl
[01:29:26.967]                           restarts <- computeRestarts(cond)
[01:29:26.967]                           for (restart in restarts) {
[01:29:26.967]                             name <- restart$name
[01:29:26.967]                             if (is.null(name)) 
[01:29:26.967]                               next
[01:29:26.967]                             if (!grepl(pattern, name)) 
[01:29:26.967]                               next
[01:29:26.967]                             invokeRestart(restart)
[01:29:26.967]                             muffled <- TRUE
[01:29:26.967]                             break
[01:29:26.967]                           }
[01:29:26.967]                         }
[01:29:26.967]                       }
[01:29:26.967]                       invisible(muffled)
[01:29:26.967]                     }
[01:29:26.967]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.967]                   }
[01:29:26.967]                 }
[01:29:26.967]             }
[01:29:26.967]         }))
[01:29:26.967]     }, error = function(ex) {
[01:29:26.967]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:26.967]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.967]                 ...future.rng), started = ...future.startTime, 
[01:29:26.967]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:26.967]             version = "1.8"), class = "FutureResult")
[01:29:26.967]     }, finally = {
[01:29:26.967]         if (!identical(...future.workdir, getwd())) 
[01:29:26.967]             setwd(...future.workdir)
[01:29:26.967]         {
[01:29:26.967]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:26.967]                 ...future.oldOptions$nwarnings <- NULL
[01:29:26.967]             }
[01:29:26.967]             base::options(...future.oldOptions)
[01:29:26.967]             if (.Platform$OS.type == "windows") {
[01:29:26.967]                 old_names <- names(...future.oldEnvVars)
[01:29:26.967]                 envs <- base::Sys.getenv()
[01:29:26.967]                 names <- names(envs)
[01:29:26.967]                 common <- intersect(names, old_names)
[01:29:26.967]                 added <- setdiff(names, old_names)
[01:29:26.967]                 removed <- setdiff(old_names, names)
[01:29:26.967]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:26.967]                   envs[common]]
[01:29:26.967]                 NAMES <- toupper(changed)
[01:29:26.967]                 args <- list()
[01:29:26.967]                 for (kk in seq_along(NAMES)) {
[01:29:26.967]                   name <- changed[[kk]]
[01:29:26.967]                   NAME <- NAMES[[kk]]
[01:29:26.967]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.967]                     next
[01:29:26.967]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.967]                 }
[01:29:26.967]                 NAMES <- toupper(added)
[01:29:26.967]                 for (kk in seq_along(NAMES)) {
[01:29:26.967]                   name <- added[[kk]]
[01:29:26.967]                   NAME <- NAMES[[kk]]
[01:29:26.967]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.967]                     next
[01:29:26.967]                   args[[name]] <- ""
[01:29:26.967]                 }
[01:29:26.967]                 NAMES <- toupper(removed)
[01:29:26.967]                 for (kk in seq_along(NAMES)) {
[01:29:26.967]                   name <- removed[[kk]]
[01:29:26.967]                   NAME <- NAMES[[kk]]
[01:29:26.967]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.967]                     next
[01:29:26.967]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.967]                 }
[01:29:26.967]                 if (length(args) > 0) 
[01:29:26.967]                   base::do.call(base::Sys.setenv, args = args)
[01:29:26.967]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:26.967]             }
[01:29:26.967]             else {
[01:29:26.967]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:26.967]             }
[01:29:26.967]             {
[01:29:26.967]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:26.967]                   0L) {
[01:29:26.967]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:26.967]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:26.967]                   base::options(opts)
[01:29:26.967]                 }
[01:29:26.967]                 {
[01:29:26.967]                   {
[01:29:26.967]                     base::assign(".Random.seed", c(10407L, 1785299503L, 
[01:29:26.967]                     125646157L, 735078412L, -1829064174L, -1260931822L, 
[01:29:26.967]                     -118514619L), envir = base::globalenv(), 
[01:29:26.967]                       inherits = FALSE)
[01:29:26.967]                     NULL
[01:29:26.967]                   }
[01:29:26.967]                   options(future.plan = NULL)
[01:29:26.967]                   if (is.na(NA_character_)) 
[01:29:26.967]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.967]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:26.967]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:26.967]                   {
[01:29:26.967]                     future <- SequentialFuture(..., envir = envir)
[01:29:26.967]                     if (!future$lazy) 
[01:29:26.967]                       future <- run(future)
[01:29:26.967]                     invisible(future)
[01:29:26.967]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:26.967]                 }
[01:29:26.967]             }
[01:29:26.967]         }
[01:29:26.967]     })
[01:29:26.967]     if (TRUE) {
[01:29:26.967]         base::sink(type = "output", split = FALSE)
[01:29:26.967]         if (TRUE) {
[01:29:26.967]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:26.967]         }
[01:29:26.967]         else {
[01:29:26.967]             ...future.result["stdout"] <- base::list(NULL)
[01:29:26.967]         }
[01:29:26.967]         base::close(...future.stdout)
[01:29:26.967]         ...future.stdout <- NULL
[01:29:26.967]     }
[01:29:26.967]     ...future.result$conditions <- ...future.conditions
[01:29:26.967]     ...future.result$finished <- base::Sys.time()
[01:29:26.967]     ...future.result
[01:29:26.967] }
[01:29:26.970] assign_globals() ...
[01:29:26.971] List of 1
[01:29:26.971]  $ x: int [1:4] 0 1 2 3
[01:29:26.971]  - attr(*, "where")=List of 1
[01:29:26.971]   ..$ x:<environment: R_EmptyEnv> 
[01:29:26.971]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:26.971]  - attr(*, "resolved")= logi FALSE
[01:29:26.971]  - attr(*, "total_size")= num 64
[01:29:26.971]  - attr(*, "already-done")= logi TRUE
[01:29:26.975] - copied 'x' to environment
[01:29:26.975] assign_globals() ... done
[01:29:26.975] plan(): Setting new future strategy stack:
[01:29:26.976] List of future strategies:
[01:29:26.976] 1. sequential:
[01:29:26.976]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.976]    - tweaked: FALSE
[01:29:26.976]    - call: NULL
[01:29:26.976] plan(): nbrOfWorkers() = 1
[01:29:26.977] plan(): Setting new future strategy stack:
[01:29:26.977] List of future strategies:
[01:29:26.977] 1. sequential:
[01:29:26.977]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.977]    - tweaked: FALSE
[01:29:26.977]    - call: plan(strategy)
[01:29:26.978] plan(): nbrOfWorkers() = 1
[01:29:26.978] SequentialFuture started (and completed)
[01:29:26.979] - Launch lazy future ... done
[01:29:26.979] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_1-340705'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96c34ae98
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:26.980] getGlobalsAndPackages() ...
[01:29:26.980] Searching for globals...
[01:29:26.981] - globals found: [3] '{', 'sample', 'x'
[01:29:26.982] Searching for globals ... DONE
[01:29:26.982] Resolving globals: FALSE
[01:29:26.982] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:26.983] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:26.983] - globals: [1] 'x'
[01:29:26.983] 
[01:29:26.983] getGlobalsAndPackages() ... DONE
[01:29:26.984] run() for 'Future' ...
[01:29:26.984] - state: 'created'
[01:29:26.984] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:26.984] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:26.985] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:26.985]   - Field: 'label'
[01:29:26.985]   - Field: 'local'
[01:29:26.985]   - Field: 'owner'
[01:29:26.985]   - Field: 'envir'
[01:29:26.985]   - Field: 'packages'
[01:29:26.986]   - Field: 'gc'
[01:29:26.986]   - Field: 'conditions'
[01:29:26.986]   - Field: 'expr'
[01:29:26.986]   - Field: 'uuid'
[01:29:26.986]   - Field: 'seed'
[01:29:26.987]   - Field: 'version'
[01:29:26.987]   - Field: 'result'
[01:29:26.987]   - Field: 'asynchronous'
[01:29:26.987]   - Field: 'calls'
[01:29:26.988]   - Field: 'globals'
[01:29:26.988]   - Field: 'stdout'
[01:29:26.988]   - Field: 'earlySignal'
[01:29:26.988]   - Field: 'lazy'
[01:29:26.989]   - Field: 'state'
[01:29:26.989] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:26.989] - Launch lazy future ...
[01:29:26.989] Packages needed by the future expression (n = 0): <none>
[01:29:26.990] Packages needed by future strategies (n = 0): <none>
[01:29:26.990] {
[01:29:26.990]     {
[01:29:26.990]         {
[01:29:26.990]             ...future.startTime <- base::Sys.time()
[01:29:26.990]             {
[01:29:26.990]                 {
[01:29:26.990]                   {
[01:29:26.990]                     base::local({
[01:29:26.990]                       has_future <- base::requireNamespace("future", 
[01:29:26.990]                         quietly = TRUE)
[01:29:26.990]                       if (has_future) {
[01:29:26.990]                         ns <- base::getNamespace("future")
[01:29:26.990]                         version <- ns[[".package"]][["version"]]
[01:29:26.990]                         if (is.null(version)) 
[01:29:26.990]                           version <- utils::packageVersion("future")
[01:29:26.990]                       }
[01:29:26.990]                       else {
[01:29:26.990]                         version <- NULL
[01:29:26.990]                       }
[01:29:26.990]                       if (!has_future || version < "1.8.0") {
[01:29:26.990]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:26.990]                           "", base::R.version$version.string), 
[01:29:26.990]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:26.990]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:26.990]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:26.990]                             "release", "version")], collapse = " "), 
[01:29:26.990]                           hostname = base::Sys.info()[["nodename"]])
[01:29:26.990]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:26.990]                           info)
[01:29:26.990]                         info <- base::paste(info, collapse = "; ")
[01:29:26.990]                         if (!has_future) {
[01:29:26.990]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:26.990]                             info)
[01:29:26.990]                         }
[01:29:26.990]                         else {
[01:29:26.990]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:26.990]                             info, version)
[01:29:26.990]                         }
[01:29:26.990]                         base::stop(msg)
[01:29:26.990]                       }
[01:29:26.990]                     })
[01:29:26.990]                   }
[01:29:26.990]                   options(future.plan = NULL)
[01:29:26.990]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.990]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:26.990]                 }
[01:29:26.990]                 ...future.workdir <- getwd()
[01:29:26.990]             }
[01:29:26.990]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:26.990]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:26.990]         }
[01:29:26.990]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:26.990]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:26.990]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:26.990]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:26.990]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:26.990]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:26.990]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:26.990]             base::names(...future.oldOptions))
[01:29:26.990]     }
[01:29:26.990]     if (FALSE) {
[01:29:26.990]     }
[01:29:26.990]     else {
[01:29:26.990]         if (TRUE) {
[01:29:26.990]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:26.990]                 open = "w")
[01:29:26.990]         }
[01:29:26.990]         else {
[01:29:26.990]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:26.990]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:26.990]         }
[01:29:26.990]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:26.990]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:26.990]             base::sink(type = "output", split = FALSE)
[01:29:26.990]             base::close(...future.stdout)
[01:29:26.990]         }, add = TRUE)
[01:29:26.990]     }
[01:29:26.990]     ...future.frame <- base::sys.nframe()
[01:29:26.990]     ...future.conditions <- base::list()
[01:29:26.990]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:26.990]     if (FALSE) {
[01:29:26.990]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:26.990]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:26.990]     }
[01:29:26.990]     ...future.result <- base::tryCatch({
[01:29:26.990]         base::withCallingHandlers({
[01:29:26.990]             ...future.value <- base::withVisible(base::local({
[01:29:26.990]                 sample(x, size = 1L)
[01:29:26.990]             }))
[01:29:26.990]             future::FutureResult(value = ...future.value$value, 
[01:29:26.990]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.990]                   ...future.rng), globalenv = if (FALSE) 
[01:29:26.990]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:26.990]                     ...future.globalenv.names))
[01:29:26.990]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:26.990]         }, condition = base::local({
[01:29:26.990]             c <- base::c
[01:29:26.990]             inherits <- base::inherits
[01:29:26.990]             invokeRestart <- base::invokeRestart
[01:29:26.990]             length <- base::length
[01:29:26.990]             list <- base::list
[01:29:26.990]             seq.int <- base::seq.int
[01:29:26.990]             signalCondition <- base::signalCondition
[01:29:26.990]             sys.calls <- base::sys.calls
[01:29:26.990]             `[[` <- base::`[[`
[01:29:26.990]             `+` <- base::`+`
[01:29:26.990]             `<<-` <- base::`<<-`
[01:29:26.990]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:26.990]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:26.990]                   3L)]
[01:29:26.990]             }
[01:29:26.990]             function(cond) {
[01:29:26.990]                 is_error <- inherits(cond, "error")
[01:29:26.990]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:26.990]                   NULL)
[01:29:26.990]                 if (is_error) {
[01:29:26.990]                   sessionInformation <- function() {
[01:29:26.990]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:26.990]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:26.990]                       search = base::search(), system = base::Sys.info())
[01:29:26.990]                   }
[01:29:26.990]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.990]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:26.990]                     cond$call), session = sessionInformation(), 
[01:29:26.990]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:26.990]                   signalCondition(cond)
[01:29:26.990]                 }
[01:29:26.990]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:26.990]                 "immediateCondition"))) {
[01:29:26.990]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:26.990]                   ...future.conditions[[length(...future.conditions) + 
[01:29:26.990]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:26.990]                   if (TRUE && !signal) {
[01:29:26.990]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.990]                     {
[01:29:26.990]                       inherits <- base::inherits
[01:29:26.990]                       invokeRestart <- base::invokeRestart
[01:29:26.990]                       is.null <- base::is.null
[01:29:26.990]                       muffled <- FALSE
[01:29:26.990]                       if (inherits(cond, "message")) {
[01:29:26.990]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.990]                         if (muffled) 
[01:29:26.990]                           invokeRestart("muffleMessage")
[01:29:26.990]                       }
[01:29:26.990]                       else if (inherits(cond, "warning")) {
[01:29:26.990]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.990]                         if (muffled) 
[01:29:26.990]                           invokeRestart("muffleWarning")
[01:29:26.990]                       }
[01:29:26.990]                       else if (inherits(cond, "condition")) {
[01:29:26.990]                         if (!is.null(pattern)) {
[01:29:26.990]                           computeRestarts <- base::computeRestarts
[01:29:26.990]                           grepl <- base::grepl
[01:29:26.990]                           restarts <- computeRestarts(cond)
[01:29:26.990]                           for (restart in restarts) {
[01:29:26.990]                             name <- restart$name
[01:29:26.990]                             if (is.null(name)) 
[01:29:26.990]                               next
[01:29:26.990]                             if (!grepl(pattern, name)) 
[01:29:26.990]                               next
[01:29:26.990]                             invokeRestart(restart)
[01:29:26.990]                             muffled <- TRUE
[01:29:26.990]                             break
[01:29:26.990]                           }
[01:29:26.990]                         }
[01:29:26.990]                       }
[01:29:26.990]                       invisible(muffled)
[01:29:26.990]                     }
[01:29:26.990]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.990]                   }
[01:29:26.990]                 }
[01:29:26.990]                 else {
[01:29:26.990]                   if (TRUE) {
[01:29:26.990]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:26.990]                     {
[01:29:26.990]                       inherits <- base::inherits
[01:29:26.990]                       invokeRestart <- base::invokeRestart
[01:29:26.990]                       is.null <- base::is.null
[01:29:26.990]                       muffled <- FALSE
[01:29:26.990]                       if (inherits(cond, "message")) {
[01:29:26.990]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:26.990]                         if (muffled) 
[01:29:26.990]                           invokeRestart("muffleMessage")
[01:29:26.990]                       }
[01:29:26.990]                       else if (inherits(cond, "warning")) {
[01:29:26.990]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:26.990]                         if (muffled) 
[01:29:26.990]                           invokeRestart("muffleWarning")
[01:29:26.990]                       }
[01:29:26.990]                       else if (inherits(cond, "condition")) {
[01:29:26.990]                         if (!is.null(pattern)) {
[01:29:26.990]                           computeRestarts <- base::computeRestarts
[01:29:26.990]                           grepl <- base::grepl
[01:29:26.990]                           restarts <- computeRestarts(cond)
[01:29:26.990]                           for (restart in restarts) {
[01:29:26.990]                             name <- restart$name
[01:29:26.990]                             if (is.null(name)) 
[01:29:26.990]                               next
[01:29:26.990]                             if (!grepl(pattern, name)) 
[01:29:26.990]                               next
[01:29:26.990]                             invokeRestart(restart)
[01:29:26.990]                             muffled <- TRUE
[01:29:26.990]                             break
[01:29:26.990]                           }
[01:29:26.990]                         }
[01:29:26.990]                       }
[01:29:26.990]                       invisible(muffled)
[01:29:26.990]                     }
[01:29:26.990]                     muffleCondition(cond, pattern = "^muffle")
[01:29:26.990]                   }
[01:29:26.990]                 }
[01:29:26.990]             }
[01:29:26.990]         }))
[01:29:26.990]     }, error = function(ex) {
[01:29:26.990]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:26.990]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:26.990]                 ...future.rng), started = ...future.startTime, 
[01:29:26.990]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:26.990]             version = "1.8"), class = "FutureResult")
[01:29:26.990]     }, finally = {
[01:29:26.990]         if (!identical(...future.workdir, getwd())) 
[01:29:26.990]             setwd(...future.workdir)
[01:29:26.990]         {
[01:29:26.990]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:26.990]                 ...future.oldOptions$nwarnings <- NULL
[01:29:26.990]             }
[01:29:26.990]             base::options(...future.oldOptions)
[01:29:26.990]             if (.Platform$OS.type == "windows") {
[01:29:26.990]                 old_names <- names(...future.oldEnvVars)
[01:29:26.990]                 envs <- base::Sys.getenv()
[01:29:26.990]                 names <- names(envs)
[01:29:26.990]                 common <- intersect(names, old_names)
[01:29:26.990]                 added <- setdiff(names, old_names)
[01:29:26.990]                 removed <- setdiff(old_names, names)
[01:29:26.990]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:26.990]                   envs[common]]
[01:29:26.990]                 NAMES <- toupper(changed)
[01:29:26.990]                 args <- list()
[01:29:26.990]                 for (kk in seq_along(NAMES)) {
[01:29:26.990]                   name <- changed[[kk]]
[01:29:26.990]                   NAME <- NAMES[[kk]]
[01:29:26.990]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.990]                     next
[01:29:26.990]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.990]                 }
[01:29:26.990]                 NAMES <- toupper(added)
[01:29:26.990]                 for (kk in seq_along(NAMES)) {
[01:29:26.990]                   name <- added[[kk]]
[01:29:26.990]                   NAME <- NAMES[[kk]]
[01:29:26.990]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.990]                     next
[01:29:26.990]                   args[[name]] <- ""
[01:29:26.990]                 }
[01:29:26.990]                 NAMES <- toupper(removed)
[01:29:26.990]                 for (kk in seq_along(NAMES)) {
[01:29:26.990]                   name <- removed[[kk]]
[01:29:26.990]                   NAME <- NAMES[[kk]]
[01:29:26.990]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:26.990]                     next
[01:29:26.990]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:26.990]                 }
[01:29:26.990]                 if (length(args) > 0) 
[01:29:26.990]                   base::do.call(base::Sys.setenv, args = args)
[01:29:26.990]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:26.990]             }
[01:29:26.990]             else {
[01:29:26.990]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:26.990]             }
[01:29:26.990]             {
[01:29:26.990]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:26.990]                   0L) {
[01:29:26.990]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:26.990]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:26.990]                   base::options(opts)
[01:29:26.990]                 }
[01:29:26.990]                 {
[01:29:26.990]                   {
[01:29:26.990]                     base::assign(".Random.seed", c(10407L, 735078412L, 
[01:29:26.990]                     1812399395L, -1054261393L, -118514619L, -1133846622L, 
[01:29:26.990]                     -881861939L), envir = base::globalenv(), 
[01:29:26.990]                       inherits = FALSE)
[01:29:26.990]                     NULL
[01:29:26.990]                   }
[01:29:26.990]                   options(future.plan = NULL)
[01:29:26.990]                   if (is.na(NA_character_)) 
[01:29:26.990]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:26.990]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:26.990]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:26.990]                   {
[01:29:26.990]                     future <- SequentialFuture(..., envir = envir)
[01:29:26.990]                     if (!future$lazy) 
[01:29:26.990]                       future <- run(future)
[01:29:26.990]                     invisible(future)
[01:29:26.990]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:26.990]                 }
[01:29:26.990]             }
[01:29:26.990]         }
[01:29:26.990]     })
[01:29:26.990]     if (TRUE) {
[01:29:26.990]         base::sink(type = "output", split = FALSE)
[01:29:26.990]         if (TRUE) {
[01:29:26.990]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:26.990]         }
[01:29:26.990]         else {
[01:29:26.990]             ...future.result["stdout"] <- base::list(NULL)
[01:29:26.990]         }
[01:29:26.990]         base::close(...future.stdout)
[01:29:26.990]         ...future.stdout <- NULL
[01:29:26.990]     }
[01:29:26.990]     ...future.result$conditions <- ...future.conditions
[01:29:26.990]     ...future.result$finished <- base::Sys.time()
[01:29:26.990]     ...future.result
[01:29:26.990] }
[01:29:26.994] assign_globals() ...
[01:29:26.994] List of 1
[01:29:26.994]  $ x: int [1:4] 0 1 2 3
[01:29:26.994]  - attr(*, "where")=List of 1
[01:29:26.994]   ..$ x:<environment: R_EmptyEnv> 
[01:29:26.994]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:26.994]  - attr(*, "resolved")= logi FALSE
[01:29:26.994]  - attr(*, "total_size")= num 64
[01:29:26.994]  - attr(*, "already-done")= logi TRUE
[01:29:26.997] - copied 'x' to environment
[01:29:26.998] assign_globals() ... done
[01:29:26.998] plan(): Setting new future strategy stack:
[01:29:26.998] List of future strategies:
[01:29:26.998] 1. sequential:
[01:29:26.998]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:26.998]    - tweaked: FALSE
[01:29:26.998]    - call: NULL
[01:29:26.999] plan(): nbrOfWorkers() = 1
[01:29:27.000] plan(): Setting new future strategy stack:
[01:29:27.000] List of future strategies:
[01:29:27.000] 1. sequential:
[01:29:27.000]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.000]    - tweaked: FALSE
[01:29:27.000]    - call: plan(strategy)
[01:29:27.001] plan(): nbrOfWorkers() = 1
[01:29:27.001] SequentialFuture started (and completed)
[01:29:27.001] - Launch lazy future ... done
[01:29:27.002] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_2-849338'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96c34ae98
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.003] getGlobalsAndPackages() ...
[01:29:27.003] Searching for globals...
[01:29:27.005] - globals found: [3] '{', 'sample', 'x'
[01:29:27.005] Searching for globals ... DONE
[01:29:27.005] Resolving globals: FALSE
[01:29:27.006] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.006] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.006] - globals: [1] 'x'
[01:29:27.006] 
[01:29:27.007] getGlobalsAndPackages() ... DONE
[01:29:27.007] run() for 'Future' ...
[01:29:27.007] - state: 'created'
[01:29:27.007] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.010] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.010] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.011]   - Field: 'label'
[01:29:27.011]   - Field: 'local'
[01:29:27.011]   - Field: 'owner'
[01:29:27.011]   - Field: 'envir'
[01:29:27.011]   - Field: 'packages'
[01:29:27.012]   - Field: 'gc'
[01:29:27.012]   - Field: 'conditions'
[01:29:27.012]   - Field: 'expr'
[01:29:27.012]   - Field: 'uuid'
[01:29:27.012]   - Field: 'seed'
[01:29:27.013]   - Field: 'version'
[01:29:27.013]   - Field: 'result'
[01:29:27.013]   - Field: 'asynchronous'
[01:29:27.013]   - Field: 'calls'
[01:29:27.013]   - Field: 'globals'
[01:29:27.014]   - Field: 'stdout'
[01:29:27.014]   - Field: 'earlySignal'
[01:29:27.014]   - Field: 'lazy'
[01:29:27.014]   - Field: 'state'
[01:29:27.014] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.015] - Launch lazy future ...
[01:29:27.015] Packages needed by the future expression (n = 0): <none>
[01:29:27.015] Packages needed by future strategies (n = 0): <none>
[01:29:27.016] {
[01:29:27.016]     {
[01:29:27.016]         {
[01:29:27.016]             ...future.startTime <- base::Sys.time()
[01:29:27.016]             {
[01:29:27.016]                 {
[01:29:27.016]                   {
[01:29:27.016]                     base::local({
[01:29:27.016]                       has_future <- base::requireNamespace("future", 
[01:29:27.016]                         quietly = TRUE)
[01:29:27.016]                       if (has_future) {
[01:29:27.016]                         ns <- base::getNamespace("future")
[01:29:27.016]                         version <- ns[[".package"]][["version"]]
[01:29:27.016]                         if (is.null(version)) 
[01:29:27.016]                           version <- utils::packageVersion("future")
[01:29:27.016]                       }
[01:29:27.016]                       else {
[01:29:27.016]                         version <- NULL
[01:29:27.016]                       }
[01:29:27.016]                       if (!has_future || version < "1.8.0") {
[01:29:27.016]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.016]                           "", base::R.version$version.string), 
[01:29:27.016]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.016]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.016]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.016]                             "release", "version")], collapse = " "), 
[01:29:27.016]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.016]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.016]                           info)
[01:29:27.016]                         info <- base::paste(info, collapse = "; ")
[01:29:27.016]                         if (!has_future) {
[01:29:27.016]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.016]                             info)
[01:29:27.016]                         }
[01:29:27.016]                         else {
[01:29:27.016]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.016]                             info, version)
[01:29:27.016]                         }
[01:29:27.016]                         base::stop(msg)
[01:29:27.016]                       }
[01:29:27.016]                     })
[01:29:27.016]                   }
[01:29:27.016]                   options(future.plan = NULL)
[01:29:27.016]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.016]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.016]                 }
[01:29:27.016]                 ...future.workdir <- getwd()
[01:29:27.016]             }
[01:29:27.016]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.016]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.016]         }
[01:29:27.016]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.016]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.016]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.016]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.016]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.016]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.016]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.016]             base::names(...future.oldOptions))
[01:29:27.016]     }
[01:29:27.016]     if (FALSE) {
[01:29:27.016]     }
[01:29:27.016]     else {
[01:29:27.016]         if (TRUE) {
[01:29:27.016]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.016]                 open = "w")
[01:29:27.016]         }
[01:29:27.016]         else {
[01:29:27.016]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.016]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.016]         }
[01:29:27.016]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.016]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.016]             base::sink(type = "output", split = FALSE)
[01:29:27.016]             base::close(...future.stdout)
[01:29:27.016]         }, add = TRUE)
[01:29:27.016]     }
[01:29:27.016]     ...future.frame <- base::sys.nframe()
[01:29:27.016]     ...future.conditions <- base::list()
[01:29:27.016]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.016]     if (FALSE) {
[01:29:27.016]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.016]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.016]     }
[01:29:27.016]     ...future.result <- base::tryCatch({
[01:29:27.016]         base::withCallingHandlers({
[01:29:27.016]             ...future.value <- base::withVisible(base::local({
[01:29:27.016]                 sample(x, size = 1L)
[01:29:27.016]             }))
[01:29:27.016]             future::FutureResult(value = ...future.value$value, 
[01:29:27.016]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.016]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.016]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.016]                     ...future.globalenv.names))
[01:29:27.016]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.016]         }, condition = base::local({
[01:29:27.016]             c <- base::c
[01:29:27.016]             inherits <- base::inherits
[01:29:27.016]             invokeRestart <- base::invokeRestart
[01:29:27.016]             length <- base::length
[01:29:27.016]             list <- base::list
[01:29:27.016]             seq.int <- base::seq.int
[01:29:27.016]             signalCondition <- base::signalCondition
[01:29:27.016]             sys.calls <- base::sys.calls
[01:29:27.016]             `[[` <- base::`[[`
[01:29:27.016]             `+` <- base::`+`
[01:29:27.016]             `<<-` <- base::`<<-`
[01:29:27.016]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.016]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.016]                   3L)]
[01:29:27.016]             }
[01:29:27.016]             function(cond) {
[01:29:27.016]                 is_error <- inherits(cond, "error")
[01:29:27.016]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.016]                   NULL)
[01:29:27.016]                 if (is_error) {
[01:29:27.016]                   sessionInformation <- function() {
[01:29:27.016]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.016]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.016]                       search = base::search(), system = base::Sys.info())
[01:29:27.016]                   }
[01:29:27.016]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.016]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.016]                     cond$call), session = sessionInformation(), 
[01:29:27.016]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.016]                   signalCondition(cond)
[01:29:27.016]                 }
[01:29:27.016]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.016]                 "immediateCondition"))) {
[01:29:27.016]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.016]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.016]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.016]                   if (TRUE && !signal) {
[01:29:27.016]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.016]                     {
[01:29:27.016]                       inherits <- base::inherits
[01:29:27.016]                       invokeRestart <- base::invokeRestart
[01:29:27.016]                       is.null <- base::is.null
[01:29:27.016]                       muffled <- FALSE
[01:29:27.016]                       if (inherits(cond, "message")) {
[01:29:27.016]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.016]                         if (muffled) 
[01:29:27.016]                           invokeRestart("muffleMessage")
[01:29:27.016]                       }
[01:29:27.016]                       else if (inherits(cond, "warning")) {
[01:29:27.016]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.016]                         if (muffled) 
[01:29:27.016]                           invokeRestart("muffleWarning")
[01:29:27.016]                       }
[01:29:27.016]                       else if (inherits(cond, "condition")) {
[01:29:27.016]                         if (!is.null(pattern)) {
[01:29:27.016]                           computeRestarts <- base::computeRestarts
[01:29:27.016]                           grepl <- base::grepl
[01:29:27.016]                           restarts <- computeRestarts(cond)
[01:29:27.016]                           for (restart in restarts) {
[01:29:27.016]                             name <- restart$name
[01:29:27.016]                             if (is.null(name)) 
[01:29:27.016]                               next
[01:29:27.016]                             if (!grepl(pattern, name)) 
[01:29:27.016]                               next
[01:29:27.016]                             invokeRestart(restart)
[01:29:27.016]                             muffled <- TRUE
[01:29:27.016]                             break
[01:29:27.016]                           }
[01:29:27.016]                         }
[01:29:27.016]                       }
[01:29:27.016]                       invisible(muffled)
[01:29:27.016]                     }
[01:29:27.016]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.016]                   }
[01:29:27.016]                 }
[01:29:27.016]                 else {
[01:29:27.016]                   if (TRUE) {
[01:29:27.016]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.016]                     {
[01:29:27.016]                       inherits <- base::inherits
[01:29:27.016]                       invokeRestart <- base::invokeRestart
[01:29:27.016]                       is.null <- base::is.null
[01:29:27.016]                       muffled <- FALSE
[01:29:27.016]                       if (inherits(cond, "message")) {
[01:29:27.016]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.016]                         if (muffled) 
[01:29:27.016]                           invokeRestart("muffleMessage")
[01:29:27.016]                       }
[01:29:27.016]                       else if (inherits(cond, "warning")) {
[01:29:27.016]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.016]                         if (muffled) 
[01:29:27.016]                           invokeRestart("muffleWarning")
[01:29:27.016]                       }
[01:29:27.016]                       else if (inherits(cond, "condition")) {
[01:29:27.016]                         if (!is.null(pattern)) {
[01:29:27.016]                           computeRestarts <- base::computeRestarts
[01:29:27.016]                           grepl <- base::grepl
[01:29:27.016]                           restarts <- computeRestarts(cond)
[01:29:27.016]                           for (restart in restarts) {
[01:29:27.016]                             name <- restart$name
[01:29:27.016]                             if (is.null(name)) 
[01:29:27.016]                               next
[01:29:27.016]                             if (!grepl(pattern, name)) 
[01:29:27.016]                               next
[01:29:27.016]                             invokeRestart(restart)
[01:29:27.016]                             muffled <- TRUE
[01:29:27.016]                             break
[01:29:27.016]                           }
[01:29:27.016]                         }
[01:29:27.016]                       }
[01:29:27.016]                       invisible(muffled)
[01:29:27.016]                     }
[01:29:27.016]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.016]                   }
[01:29:27.016]                 }
[01:29:27.016]             }
[01:29:27.016]         }))
[01:29:27.016]     }, error = function(ex) {
[01:29:27.016]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.016]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.016]                 ...future.rng), started = ...future.startTime, 
[01:29:27.016]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.016]             version = "1.8"), class = "FutureResult")
[01:29:27.016]     }, finally = {
[01:29:27.016]         if (!identical(...future.workdir, getwd())) 
[01:29:27.016]             setwd(...future.workdir)
[01:29:27.016]         {
[01:29:27.016]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.016]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.016]             }
[01:29:27.016]             base::options(...future.oldOptions)
[01:29:27.016]             if (.Platform$OS.type == "windows") {
[01:29:27.016]                 old_names <- names(...future.oldEnvVars)
[01:29:27.016]                 envs <- base::Sys.getenv()
[01:29:27.016]                 names <- names(envs)
[01:29:27.016]                 common <- intersect(names, old_names)
[01:29:27.016]                 added <- setdiff(names, old_names)
[01:29:27.016]                 removed <- setdiff(old_names, names)
[01:29:27.016]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.016]                   envs[common]]
[01:29:27.016]                 NAMES <- toupper(changed)
[01:29:27.016]                 args <- list()
[01:29:27.016]                 for (kk in seq_along(NAMES)) {
[01:29:27.016]                   name <- changed[[kk]]
[01:29:27.016]                   NAME <- NAMES[[kk]]
[01:29:27.016]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.016]                     next
[01:29:27.016]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.016]                 }
[01:29:27.016]                 NAMES <- toupper(added)
[01:29:27.016]                 for (kk in seq_along(NAMES)) {
[01:29:27.016]                   name <- added[[kk]]
[01:29:27.016]                   NAME <- NAMES[[kk]]
[01:29:27.016]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.016]                     next
[01:29:27.016]                   args[[name]] <- ""
[01:29:27.016]                 }
[01:29:27.016]                 NAMES <- toupper(removed)
[01:29:27.016]                 for (kk in seq_along(NAMES)) {
[01:29:27.016]                   name <- removed[[kk]]
[01:29:27.016]                   NAME <- NAMES[[kk]]
[01:29:27.016]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.016]                     next
[01:29:27.016]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.016]                 }
[01:29:27.016]                 if (length(args) > 0) 
[01:29:27.016]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.016]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.016]             }
[01:29:27.016]             else {
[01:29:27.016]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.016]             }
[01:29:27.016]             {
[01:29:27.016]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.016]                   0L) {
[01:29:27.016]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.016]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.016]                   base::options(opts)
[01:29:27.016]                 }
[01:29:27.016]                 {
[01:29:27.016]                   {
[01:29:27.016]                     base::assign(".Random.seed", c(10407L, -1054261393L, 
[01:29:27.016]                     -1825904242L, 1941203574L, -881861939L, 1224514573L, 
[01:29:27.016]                     -1732441100L), envir = base::globalenv(), 
[01:29:27.016]                       inherits = FALSE)
[01:29:27.016]                     NULL
[01:29:27.016]                   }
[01:29:27.016]                   options(future.plan = NULL)
[01:29:27.016]                   if (is.na(NA_character_)) 
[01:29:27.016]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.016]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.016]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.016]                   {
[01:29:27.016]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.016]                     if (!future$lazy) 
[01:29:27.016]                       future <- run(future)
[01:29:27.016]                     invisible(future)
[01:29:27.016]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.016]                 }
[01:29:27.016]             }
[01:29:27.016]         }
[01:29:27.016]     })
[01:29:27.016]     if (TRUE) {
[01:29:27.016]         base::sink(type = "output", split = FALSE)
[01:29:27.016]         if (TRUE) {
[01:29:27.016]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.016]         }
[01:29:27.016]         else {
[01:29:27.016]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.016]         }
[01:29:27.016]         base::close(...future.stdout)
[01:29:27.016]         ...future.stdout <- NULL
[01:29:27.016]     }
[01:29:27.016]     ...future.result$conditions <- ...future.conditions
[01:29:27.016]     ...future.result$finished <- base::Sys.time()
[01:29:27.016]     ...future.result
[01:29:27.016] }
[01:29:27.020] assign_globals() ...
[01:29:27.020] List of 1
[01:29:27.020]  $ x: int [1:4] 0 1 2 3
[01:29:27.020]  - attr(*, "where")=List of 1
[01:29:27.020]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.020]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.020]  - attr(*, "resolved")= logi FALSE
[01:29:27.020]  - attr(*, "total_size")= num 64
[01:29:27.020]  - attr(*, "already-done")= logi TRUE
[01:29:27.024] - copied 'x' to environment
[01:29:27.024] assign_globals() ... done
[01:29:27.025] plan(): Setting new future strategy stack:
[01:29:27.025] List of future strategies:
[01:29:27.025] 1. sequential:
[01:29:27.025]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.025]    - tweaked: FALSE
[01:29:27.025]    - call: NULL
[01:29:27.026] plan(): nbrOfWorkers() = 1
[01:29:27.027] plan(): Setting new future strategy stack:
[01:29:27.027] List of future strategies:
[01:29:27.027] 1. sequential:
[01:29:27.027]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.027]    - tweaked: FALSE
[01:29:27.027]    - call: plan(strategy)
[01:29:27.028] plan(): nbrOfWorkers() = 1
[01:29:27.028] SequentialFuture started (and completed)
[01:29:27.029] - Launch lazy future ... done
[01:29:27.029] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_3-973560'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96c34ae98
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.030] getGlobalsAndPackages() ...
[01:29:27.031] Searching for globals...
[01:29:27.032] - globals found: [3] '{', 'sample', 'x'
[01:29:27.032] Searching for globals ... DONE
[01:29:27.033] Resolving globals: FALSE
[01:29:27.033] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.034] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.034] - globals: [1] 'x'
[01:29:27.034] 
[01:29:27.034] getGlobalsAndPackages() ... DONE
[01:29:27.035] run() for 'Future' ...
[01:29:27.035] - state: 'created'
[01:29:27.035] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.036] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.036] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.036]   - Field: 'label'
[01:29:27.036]   - Field: 'local'
[01:29:27.037]   - Field: 'owner'
[01:29:27.037]   - Field: 'envir'
[01:29:27.037]   - Field: 'packages'
[01:29:27.037]   - Field: 'gc'
[01:29:27.038]   - Field: 'conditions'
[01:29:27.038]   - Field: 'expr'
[01:29:27.038]   - Field: 'uuid'
[01:29:27.038]   - Field: 'seed'
[01:29:27.038]   - Field: 'version'
[01:29:27.039]   - Field: 'result'
[01:29:27.039]   - Field: 'asynchronous'
[01:29:27.039]   - Field: 'calls'
[01:29:27.039]   - Field: 'globals'
[01:29:27.039]   - Field: 'stdout'
[01:29:27.040]   - Field: 'earlySignal'
[01:29:27.040]   - Field: 'lazy'
[01:29:27.040]   - Field: 'state'
[01:29:27.040] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.040] - Launch lazy future ...
[01:29:27.041] Packages needed by the future expression (n = 0): <none>
[01:29:27.041] Packages needed by future strategies (n = 0): <none>
[01:29:27.042] {
[01:29:27.042]     {
[01:29:27.042]         {
[01:29:27.042]             ...future.startTime <- base::Sys.time()
[01:29:27.042]             {
[01:29:27.042]                 {
[01:29:27.042]                   {
[01:29:27.042]                     base::local({
[01:29:27.042]                       has_future <- base::requireNamespace("future", 
[01:29:27.042]                         quietly = TRUE)
[01:29:27.042]                       if (has_future) {
[01:29:27.042]                         ns <- base::getNamespace("future")
[01:29:27.042]                         version <- ns[[".package"]][["version"]]
[01:29:27.042]                         if (is.null(version)) 
[01:29:27.042]                           version <- utils::packageVersion("future")
[01:29:27.042]                       }
[01:29:27.042]                       else {
[01:29:27.042]                         version <- NULL
[01:29:27.042]                       }
[01:29:27.042]                       if (!has_future || version < "1.8.0") {
[01:29:27.042]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.042]                           "", base::R.version$version.string), 
[01:29:27.042]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.042]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.042]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.042]                             "release", "version")], collapse = " "), 
[01:29:27.042]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.042]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.042]                           info)
[01:29:27.042]                         info <- base::paste(info, collapse = "; ")
[01:29:27.042]                         if (!has_future) {
[01:29:27.042]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.042]                             info)
[01:29:27.042]                         }
[01:29:27.042]                         else {
[01:29:27.042]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.042]                             info, version)
[01:29:27.042]                         }
[01:29:27.042]                         base::stop(msg)
[01:29:27.042]                       }
[01:29:27.042]                     })
[01:29:27.042]                   }
[01:29:27.042]                   options(future.plan = NULL)
[01:29:27.042]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.042]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.042]                 }
[01:29:27.042]                 ...future.workdir <- getwd()
[01:29:27.042]             }
[01:29:27.042]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.042]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.042]         }
[01:29:27.042]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.042]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.042]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.042]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.042]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.042]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.042]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.042]             base::names(...future.oldOptions))
[01:29:27.042]     }
[01:29:27.042]     if (FALSE) {
[01:29:27.042]     }
[01:29:27.042]     else {
[01:29:27.042]         if (TRUE) {
[01:29:27.042]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.042]                 open = "w")
[01:29:27.042]         }
[01:29:27.042]         else {
[01:29:27.042]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.042]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.042]         }
[01:29:27.042]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.042]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.042]             base::sink(type = "output", split = FALSE)
[01:29:27.042]             base::close(...future.stdout)
[01:29:27.042]         }, add = TRUE)
[01:29:27.042]     }
[01:29:27.042]     ...future.frame <- base::sys.nframe()
[01:29:27.042]     ...future.conditions <- base::list()
[01:29:27.042]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.042]     if (FALSE) {
[01:29:27.042]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.042]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.042]     }
[01:29:27.042]     ...future.result <- base::tryCatch({
[01:29:27.042]         base::withCallingHandlers({
[01:29:27.042]             ...future.value <- base::withVisible(base::local({
[01:29:27.042]                 sample(x, size = 1L)
[01:29:27.042]             }))
[01:29:27.042]             future::FutureResult(value = ...future.value$value, 
[01:29:27.042]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.042]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.042]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.042]                     ...future.globalenv.names))
[01:29:27.042]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.042]         }, condition = base::local({
[01:29:27.042]             c <- base::c
[01:29:27.042]             inherits <- base::inherits
[01:29:27.042]             invokeRestart <- base::invokeRestart
[01:29:27.042]             length <- base::length
[01:29:27.042]             list <- base::list
[01:29:27.042]             seq.int <- base::seq.int
[01:29:27.042]             signalCondition <- base::signalCondition
[01:29:27.042]             sys.calls <- base::sys.calls
[01:29:27.042]             `[[` <- base::`[[`
[01:29:27.042]             `+` <- base::`+`
[01:29:27.042]             `<<-` <- base::`<<-`
[01:29:27.042]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.042]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.042]                   3L)]
[01:29:27.042]             }
[01:29:27.042]             function(cond) {
[01:29:27.042]                 is_error <- inherits(cond, "error")
[01:29:27.042]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.042]                   NULL)
[01:29:27.042]                 if (is_error) {
[01:29:27.042]                   sessionInformation <- function() {
[01:29:27.042]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.042]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.042]                       search = base::search(), system = base::Sys.info())
[01:29:27.042]                   }
[01:29:27.042]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.042]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.042]                     cond$call), session = sessionInformation(), 
[01:29:27.042]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.042]                   signalCondition(cond)
[01:29:27.042]                 }
[01:29:27.042]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.042]                 "immediateCondition"))) {
[01:29:27.042]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.042]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.042]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.042]                   if (TRUE && !signal) {
[01:29:27.042]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.042]                     {
[01:29:27.042]                       inherits <- base::inherits
[01:29:27.042]                       invokeRestart <- base::invokeRestart
[01:29:27.042]                       is.null <- base::is.null
[01:29:27.042]                       muffled <- FALSE
[01:29:27.042]                       if (inherits(cond, "message")) {
[01:29:27.042]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.042]                         if (muffled) 
[01:29:27.042]                           invokeRestart("muffleMessage")
[01:29:27.042]                       }
[01:29:27.042]                       else if (inherits(cond, "warning")) {
[01:29:27.042]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.042]                         if (muffled) 
[01:29:27.042]                           invokeRestart("muffleWarning")
[01:29:27.042]                       }
[01:29:27.042]                       else if (inherits(cond, "condition")) {
[01:29:27.042]                         if (!is.null(pattern)) {
[01:29:27.042]                           computeRestarts <- base::computeRestarts
[01:29:27.042]                           grepl <- base::grepl
[01:29:27.042]                           restarts <- computeRestarts(cond)
[01:29:27.042]                           for (restart in restarts) {
[01:29:27.042]                             name <- restart$name
[01:29:27.042]                             if (is.null(name)) 
[01:29:27.042]                               next
[01:29:27.042]                             if (!grepl(pattern, name)) 
[01:29:27.042]                               next
[01:29:27.042]                             invokeRestart(restart)
[01:29:27.042]                             muffled <- TRUE
[01:29:27.042]                             break
[01:29:27.042]                           }
[01:29:27.042]                         }
[01:29:27.042]                       }
[01:29:27.042]                       invisible(muffled)
[01:29:27.042]                     }
[01:29:27.042]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.042]                   }
[01:29:27.042]                 }
[01:29:27.042]                 else {
[01:29:27.042]                   if (TRUE) {
[01:29:27.042]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.042]                     {
[01:29:27.042]                       inherits <- base::inherits
[01:29:27.042]                       invokeRestart <- base::invokeRestart
[01:29:27.042]                       is.null <- base::is.null
[01:29:27.042]                       muffled <- FALSE
[01:29:27.042]                       if (inherits(cond, "message")) {
[01:29:27.042]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.042]                         if (muffled) 
[01:29:27.042]                           invokeRestart("muffleMessage")
[01:29:27.042]                       }
[01:29:27.042]                       else if (inherits(cond, "warning")) {
[01:29:27.042]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.042]                         if (muffled) 
[01:29:27.042]                           invokeRestart("muffleWarning")
[01:29:27.042]                       }
[01:29:27.042]                       else if (inherits(cond, "condition")) {
[01:29:27.042]                         if (!is.null(pattern)) {
[01:29:27.042]                           computeRestarts <- base::computeRestarts
[01:29:27.042]                           grepl <- base::grepl
[01:29:27.042]                           restarts <- computeRestarts(cond)
[01:29:27.042]                           for (restart in restarts) {
[01:29:27.042]                             name <- restart$name
[01:29:27.042]                             if (is.null(name)) 
[01:29:27.042]                               next
[01:29:27.042]                             if (!grepl(pattern, name)) 
[01:29:27.042]                               next
[01:29:27.042]                             invokeRestart(restart)
[01:29:27.042]                             muffled <- TRUE
[01:29:27.042]                             break
[01:29:27.042]                           }
[01:29:27.042]                         }
[01:29:27.042]                       }
[01:29:27.042]                       invisible(muffled)
[01:29:27.042]                     }
[01:29:27.042]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.042]                   }
[01:29:27.042]                 }
[01:29:27.042]             }
[01:29:27.042]         }))
[01:29:27.042]     }, error = function(ex) {
[01:29:27.042]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.042]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.042]                 ...future.rng), started = ...future.startTime, 
[01:29:27.042]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.042]             version = "1.8"), class = "FutureResult")
[01:29:27.042]     }, finally = {
[01:29:27.042]         if (!identical(...future.workdir, getwd())) 
[01:29:27.042]             setwd(...future.workdir)
[01:29:27.042]         {
[01:29:27.042]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.042]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.042]             }
[01:29:27.042]             base::options(...future.oldOptions)
[01:29:27.042]             if (.Platform$OS.type == "windows") {
[01:29:27.042]                 old_names <- names(...future.oldEnvVars)
[01:29:27.042]                 envs <- base::Sys.getenv()
[01:29:27.042]                 names <- names(envs)
[01:29:27.042]                 common <- intersect(names, old_names)
[01:29:27.042]                 added <- setdiff(names, old_names)
[01:29:27.042]                 removed <- setdiff(old_names, names)
[01:29:27.042]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.042]                   envs[common]]
[01:29:27.042]                 NAMES <- toupper(changed)
[01:29:27.042]                 args <- list()
[01:29:27.042]                 for (kk in seq_along(NAMES)) {
[01:29:27.042]                   name <- changed[[kk]]
[01:29:27.042]                   NAME <- NAMES[[kk]]
[01:29:27.042]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.042]                     next
[01:29:27.042]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.042]                 }
[01:29:27.042]                 NAMES <- toupper(added)
[01:29:27.042]                 for (kk in seq_along(NAMES)) {
[01:29:27.042]                   name <- added[[kk]]
[01:29:27.042]                   NAME <- NAMES[[kk]]
[01:29:27.042]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.042]                     next
[01:29:27.042]                   args[[name]] <- ""
[01:29:27.042]                 }
[01:29:27.042]                 NAMES <- toupper(removed)
[01:29:27.042]                 for (kk in seq_along(NAMES)) {
[01:29:27.042]                   name <- removed[[kk]]
[01:29:27.042]                   NAME <- NAMES[[kk]]
[01:29:27.042]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.042]                     next
[01:29:27.042]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.042]                 }
[01:29:27.042]                 if (length(args) > 0) 
[01:29:27.042]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.042]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.042]             }
[01:29:27.042]             else {
[01:29:27.042]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.042]             }
[01:29:27.042]             {
[01:29:27.042]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.042]                   0L) {
[01:29:27.042]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.042]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.042]                   base::options(opts)
[01:29:27.042]                 }
[01:29:27.042]                 {
[01:29:27.042]                   {
[01:29:27.042]                     base::assign(".Random.seed", c(10407L, 1941203574L, 
[01:29:27.042]                     -680759019L, 1460404464L, -1732441100L, -239407176L, 
[01:29:27.042]                     -1438927716L), envir = base::globalenv(), 
[01:29:27.042]                       inherits = FALSE)
[01:29:27.042]                     NULL
[01:29:27.042]                   }
[01:29:27.042]                   options(future.plan = NULL)
[01:29:27.042]                   if (is.na(NA_character_)) 
[01:29:27.042]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.042]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.042]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.042]                   {
[01:29:27.042]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.042]                     if (!future$lazy) 
[01:29:27.042]                       future <- run(future)
[01:29:27.042]                     invisible(future)
[01:29:27.042]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.042]                 }
[01:29:27.042]             }
[01:29:27.042]         }
[01:29:27.042]     })
[01:29:27.042]     if (TRUE) {
[01:29:27.042]         base::sink(type = "output", split = FALSE)
[01:29:27.042]         if (TRUE) {
[01:29:27.042]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.042]         }
[01:29:27.042]         else {
[01:29:27.042]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.042]         }
[01:29:27.042]         base::close(...future.stdout)
[01:29:27.042]         ...future.stdout <- NULL
[01:29:27.042]     }
[01:29:27.042]     ...future.result$conditions <- ...future.conditions
[01:29:27.042]     ...future.result$finished <- base::Sys.time()
[01:29:27.042]     ...future.result
[01:29:27.042] }
[01:29:27.046] assign_globals() ...
[01:29:27.046] List of 1
[01:29:27.046]  $ x: int [1:4] 0 1 2 3
[01:29:27.046]  - attr(*, "where")=List of 1
[01:29:27.046]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.046]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.046]  - attr(*, "resolved")= logi FALSE
[01:29:27.046]  - attr(*, "total_size")= num 64
[01:29:27.046]  - attr(*, "already-done")= logi TRUE
[01:29:27.050] - copied 'x' to environment
[01:29:27.050] assign_globals() ... done
[01:29:27.050] plan(): Setting new future strategy stack:
[01:29:27.051] List of future strategies:
[01:29:27.051] 1. sequential:
[01:29:27.051]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.051]    - tweaked: FALSE
[01:29:27.051]    - call: NULL
[01:29:27.054] plan(): nbrOfWorkers() = 1
[01:29:27.055] plan(): Setting new future strategy stack:
[01:29:27.056] List of future strategies:
[01:29:27.056] 1. sequential:
[01:29:27.056]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.056]    - tweaked: FALSE
[01:29:27.056]    - call: plan(strategy)
[01:29:27.056] plan(): nbrOfWorkers() = 1
[01:29:27.057] SequentialFuture started (and completed)
[01:29:27.057] - Launch lazy future ... done
[01:29:27.057] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_4-109777'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96c34ae98
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.058] resolve() on list ...
[01:29:27.059]  recursive: 0
[01:29:27.059]  length: 4
[01:29:27.059] 
[01:29:27.059] resolved() for 'SequentialFuture' ...
[01:29:27.059] - state: 'finished'
[01:29:27.060] - run: TRUE
[01:29:27.060] - result: 'FutureResult'
[01:29:27.060] resolved() for 'SequentialFuture' ... done
[01:29:27.060] Future #1
[01:29:27.061] signalConditionsASAP(SequentialFuture, pos=1) ...
[01:29:27.061] - nx: 4
[01:29:27.061] - relay: TRUE
[01:29:27.061] - stdout: TRUE
[01:29:27.061] - signal: TRUE
[01:29:27.062] - resignal: FALSE
[01:29:27.062] - force: TRUE
[01:29:27.062] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:27.062] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:27.062]  - until=1
[01:29:27.063]  - relaying element #1
[01:29:27.063] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:27.063] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:27.063] signalConditionsASAP(SequentialFuture, pos=1) ... done
[01:29:27.064]  length: 3 (resolved future 1)
[01:29:27.064] resolved() for 'SequentialFuture' ...
[01:29:27.064] - state: 'finished'
[01:29:27.064] - run: TRUE
[01:29:27.065] - result: 'FutureResult'
[01:29:27.065] resolved() for 'SequentialFuture' ... done
[01:29:27.065] Future #2
[01:29:27.065] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:29:27.066] - nx: 4
[01:29:27.066] - relay: TRUE
[01:29:27.066] - stdout: TRUE
[01:29:27.066] - signal: TRUE
[01:29:27.066] - resignal: FALSE
[01:29:27.067] - force: TRUE
[01:29:27.067] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:27.067] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:27.067]  - until=2
[01:29:27.068]  - relaying element #2
[01:29:27.068] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:27.068] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:27.068] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:29:27.069]  length: 2 (resolved future 2)
[01:29:27.069] resolved() for 'SequentialFuture' ...
[01:29:27.069] - state: 'finished'
[01:29:27.069] - run: TRUE
[01:29:27.069] - result: 'FutureResult'
[01:29:27.070] resolved() for 'SequentialFuture' ... done
[01:29:27.070] Future #3
[01:29:27.070] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:29:27.071] - nx: 4
[01:29:27.071] - relay: TRUE
[01:29:27.071] - stdout: TRUE
[01:29:27.071] - signal: TRUE
[01:29:27.071] - resignal: FALSE
[01:29:27.072] - force: TRUE
[01:29:27.072] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:27.072] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:27.072]  - until=3
[01:29:27.073]  - relaying element #3
[01:29:27.073] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:27.073] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:27.073] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:29:27.074]  length: 1 (resolved future 3)
[01:29:27.074] resolved() for 'SequentialFuture' ...
[01:29:27.074] - state: 'finished'
[01:29:27.074] - run: TRUE
[01:29:27.074] - result: 'FutureResult'
[01:29:27.075] resolved() for 'SequentialFuture' ... done
[01:29:27.075] Future #4
[01:29:27.075] signalConditionsASAP(SequentialFuture, pos=4) ...
[01:29:27.075] - nx: 4
[01:29:27.076] - relay: TRUE
[01:29:27.076] - stdout: TRUE
[01:29:27.076] - signal: TRUE
[01:29:27.076] - resignal: FALSE
[01:29:27.076] - force: TRUE
[01:29:27.076] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:27.077] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:27.077]  - until=4
[01:29:27.077]  - relaying element #4
[01:29:27.077] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.078] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.078] signalConditionsASAP(SequentialFuture, pos=4) ... done
[01:29:27.078]  length: 0 (resolved future 4)
[01:29:27.078] Relaying remaining futures
[01:29:27.078] signalConditionsASAP(NULL, pos=0) ...
[01:29:27.079] - nx: 4
[01:29:27.079] - relay: TRUE
[01:29:27.079] - stdout: TRUE
[01:29:27.079] - signal: TRUE
[01:29:27.079] - resignal: FALSE
[01:29:27.079] - force: TRUE
[01:29:27.079] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.080] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[01:29:27.080] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.080] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.080] signalConditionsASAP(NULL, pos=0) ... done
[01:29:27.081] resolve() on list ... DONE
[[1]]
[1] 0

[[2]]
[1] 2

[[3]]
[1] 1

[[4]]
[1] 3

[01:29:27.081] getGlobalsAndPackages() ...
[01:29:27.081] Searching for globals...
[01:29:27.083] - globals found: [3] '{', 'sample', 'x'
[01:29:27.083] Searching for globals ... DONE
[01:29:27.083] Resolving globals: FALSE
[01:29:27.084] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.084] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.084] - globals: [1] 'x'
[01:29:27.085] 
[01:29:27.085] getGlobalsAndPackages() ... DONE
[01:29:27.085] run() for 'Future' ...
[01:29:27.085] - state: 'created'
[01:29:27.086] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.086] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.086] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.086]   - Field: 'label'
[01:29:27.087]   - Field: 'local'
[01:29:27.087]   - Field: 'owner'
[01:29:27.087]   - Field: 'envir'
[01:29:27.087]   - Field: 'packages'
[01:29:27.087]   - Field: 'gc'
[01:29:27.087]   - Field: 'conditions'
[01:29:27.088]   - Field: 'expr'
[01:29:27.088]   - Field: 'uuid'
[01:29:27.088]   - Field: 'seed'
[01:29:27.088]   - Field: 'version'
[01:29:27.088]   - Field: 'result'
[01:29:27.089]   - Field: 'asynchronous'
[01:29:27.089]   - Field: 'calls'
[01:29:27.091]   - Field: 'globals'
[01:29:27.091]   - Field: 'stdout'
[01:29:27.092]   - Field: 'earlySignal'
[01:29:27.092]   - Field: 'lazy'
[01:29:27.092]   - Field: 'state'
[01:29:27.092] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.092] - Launch lazy future ...
[01:29:27.093] Packages needed by the future expression (n = 0): <none>
[01:29:27.093] Packages needed by future strategies (n = 0): <none>
[01:29:27.093] {
[01:29:27.093]     {
[01:29:27.093]         {
[01:29:27.093]             ...future.startTime <- base::Sys.time()
[01:29:27.093]             {
[01:29:27.093]                 {
[01:29:27.093]                   {
[01:29:27.093]                     base::local({
[01:29:27.093]                       has_future <- base::requireNamespace("future", 
[01:29:27.093]                         quietly = TRUE)
[01:29:27.093]                       if (has_future) {
[01:29:27.093]                         ns <- base::getNamespace("future")
[01:29:27.093]                         version <- ns[[".package"]][["version"]]
[01:29:27.093]                         if (is.null(version)) 
[01:29:27.093]                           version <- utils::packageVersion("future")
[01:29:27.093]                       }
[01:29:27.093]                       else {
[01:29:27.093]                         version <- NULL
[01:29:27.093]                       }
[01:29:27.093]                       if (!has_future || version < "1.8.0") {
[01:29:27.093]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.093]                           "", base::R.version$version.string), 
[01:29:27.093]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.093]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.093]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.093]                             "release", "version")], collapse = " "), 
[01:29:27.093]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.093]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.093]                           info)
[01:29:27.093]                         info <- base::paste(info, collapse = "; ")
[01:29:27.093]                         if (!has_future) {
[01:29:27.093]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.093]                             info)
[01:29:27.093]                         }
[01:29:27.093]                         else {
[01:29:27.093]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.093]                             info, version)
[01:29:27.093]                         }
[01:29:27.093]                         base::stop(msg)
[01:29:27.093]                       }
[01:29:27.093]                     })
[01:29:27.093]                   }
[01:29:27.093]                   options(future.plan = NULL)
[01:29:27.093]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.093]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.093]                 }
[01:29:27.093]                 ...future.workdir <- getwd()
[01:29:27.093]             }
[01:29:27.093]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.093]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.093]         }
[01:29:27.093]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.093]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.093]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.093]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.093]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.093]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.093]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.093]             base::names(...future.oldOptions))
[01:29:27.093]     }
[01:29:27.093]     if (FALSE) {
[01:29:27.093]     }
[01:29:27.093]     else {
[01:29:27.093]         if (TRUE) {
[01:29:27.093]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.093]                 open = "w")
[01:29:27.093]         }
[01:29:27.093]         else {
[01:29:27.093]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.093]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.093]         }
[01:29:27.093]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.093]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.093]             base::sink(type = "output", split = FALSE)
[01:29:27.093]             base::close(...future.stdout)
[01:29:27.093]         }, add = TRUE)
[01:29:27.093]     }
[01:29:27.093]     ...future.frame <- base::sys.nframe()
[01:29:27.093]     ...future.conditions <- base::list()
[01:29:27.093]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.093]     if (FALSE) {
[01:29:27.093]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.093]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.093]     }
[01:29:27.093]     ...future.result <- base::tryCatch({
[01:29:27.093]         base::withCallingHandlers({
[01:29:27.093]             ...future.value <- base::withVisible(base::local({
[01:29:27.093]                 sample(x, size = 1L)
[01:29:27.093]             }))
[01:29:27.093]             future::FutureResult(value = ...future.value$value, 
[01:29:27.093]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.093]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.093]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.093]                     ...future.globalenv.names))
[01:29:27.093]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.093]         }, condition = base::local({
[01:29:27.093]             c <- base::c
[01:29:27.093]             inherits <- base::inherits
[01:29:27.093]             invokeRestart <- base::invokeRestart
[01:29:27.093]             length <- base::length
[01:29:27.093]             list <- base::list
[01:29:27.093]             seq.int <- base::seq.int
[01:29:27.093]             signalCondition <- base::signalCondition
[01:29:27.093]             sys.calls <- base::sys.calls
[01:29:27.093]             `[[` <- base::`[[`
[01:29:27.093]             `+` <- base::`+`
[01:29:27.093]             `<<-` <- base::`<<-`
[01:29:27.093]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.093]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.093]                   3L)]
[01:29:27.093]             }
[01:29:27.093]             function(cond) {
[01:29:27.093]                 is_error <- inherits(cond, "error")
[01:29:27.093]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.093]                   NULL)
[01:29:27.093]                 if (is_error) {
[01:29:27.093]                   sessionInformation <- function() {
[01:29:27.093]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.093]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.093]                       search = base::search(), system = base::Sys.info())
[01:29:27.093]                   }
[01:29:27.093]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.093]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.093]                     cond$call), session = sessionInformation(), 
[01:29:27.093]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.093]                   signalCondition(cond)
[01:29:27.093]                 }
[01:29:27.093]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.093]                 "immediateCondition"))) {
[01:29:27.093]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.093]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.093]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.093]                   if (TRUE && !signal) {
[01:29:27.093]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.093]                     {
[01:29:27.093]                       inherits <- base::inherits
[01:29:27.093]                       invokeRestart <- base::invokeRestart
[01:29:27.093]                       is.null <- base::is.null
[01:29:27.093]                       muffled <- FALSE
[01:29:27.093]                       if (inherits(cond, "message")) {
[01:29:27.093]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.093]                         if (muffled) 
[01:29:27.093]                           invokeRestart("muffleMessage")
[01:29:27.093]                       }
[01:29:27.093]                       else if (inherits(cond, "warning")) {
[01:29:27.093]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.093]                         if (muffled) 
[01:29:27.093]                           invokeRestart("muffleWarning")
[01:29:27.093]                       }
[01:29:27.093]                       else if (inherits(cond, "condition")) {
[01:29:27.093]                         if (!is.null(pattern)) {
[01:29:27.093]                           computeRestarts <- base::computeRestarts
[01:29:27.093]                           grepl <- base::grepl
[01:29:27.093]                           restarts <- computeRestarts(cond)
[01:29:27.093]                           for (restart in restarts) {
[01:29:27.093]                             name <- restart$name
[01:29:27.093]                             if (is.null(name)) 
[01:29:27.093]                               next
[01:29:27.093]                             if (!grepl(pattern, name)) 
[01:29:27.093]                               next
[01:29:27.093]                             invokeRestart(restart)
[01:29:27.093]                             muffled <- TRUE
[01:29:27.093]                             break
[01:29:27.093]                           }
[01:29:27.093]                         }
[01:29:27.093]                       }
[01:29:27.093]                       invisible(muffled)
[01:29:27.093]                     }
[01:29:27.093]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.093]                   }
[01:29:27.093]                 }
[01:29:27.093]                 else {
[01:29:27.093]                   if (TRUE) {
[01:29:27.093]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.093]                     {
[01:29:27.093]                       inherits <- base::inherits
[01:29:27.093]                       invokeRestart <- base::invokeRestart
[01:29:27.093]                       is.null <- base::is.null
[01:29:27.093]                       muffled <- FALSE
[01:29:27.093]                       if (inherits(cond, "message")) {
[01:29:27.093]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.093]                         if (muffled) 
[01:29:27.093]                           invokeRestart("muffleMessage")
[01:29:27.093]                       }
[01:29:27.093]                       else if (inherits(cond, "warning")) {
[01:29:27.093]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.093]                         if (muffled) 
[01:29:27.093]                           invokeRestart("muffleWarning")
[01:29:27.093]                       }
[01:29:27.093]                       else if (inherits(cond, "condition")) {
[01:29:27.093]                         if (!is.null(pattern)) {
[01:29:27.093]                           computeRestarts <- base::computeRestarts
[01:29:27.093]                           grepl <- base::grepl
[01:29:27.093]                           restarts <- computeRestarts(cond)
[01:29:27.093]                           for (restart in restarts) {
[01:29:27.093]                             name <- restart$name
[01:29:27.093]                             if (is.null(name)) 
[01:29:27.093]                               next
[01:29:27.093]                             if (!grepl(pattern, name)) 
[01:29:27.093]                               next
[01:29:27.093]                             invokeRestart(restart)
[01:29:27.093]                             muffled <- TRUE
[01:29:27.093]                             break
[01:29:27.093]                           }
[01:29:27.093]                         }
[01:29:27.093]                       }
[01:29:27.093]                       invisible(muffled)
[01:29:27.093]                     }
[01:29:27.093]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.093]                   }
[01:29:27.093]                 }
[01:29:27.093]             }
[01:29:27.093]         }))
[01:29:27.093]     }, error = function(ex) {
[01:29:27.093]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.093]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.093]                 ...future.rng), started = ...future.startTime, 
[01:29:27.093]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.093]             version = "1.8"), class = "FutureResult")
[01:29:27.093]     }, finally = {
[01:29:27.093]         if (!identical(...future.workdir, getwd())) 
[01:29:27.093]             setwd(...future.workdir)
[01:29:27.093]         {
[01:29:27.093]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.093]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.093]             }
[01:29:27.093]             base::options(...future.oldOptions)
[01:29:27.093]             if (.Platform$OS.type == "windows") {
[01:29:27.093]                 old_names <- names(...future.oldEnvVars)
[01:29:27.093]                 envs <- base::Sys.getenv()
[01:29:27.093]                 names <- names(envs)
[01:29:27.093]                 common <- intersect(names, old_names)
[01:29:27.093]                 added <- setdiff(names, old_names)
[01:29:27.093]                 removed <- setdiff(old_names, names)
[01:29:27.093]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.093]                   envs[common]]
[01:29:27.093]                 NAMES <- toupper(changed)
[01:29:27.093]                 args <- list()
[01:29:27.093]                 for (kk in seq_along(NAMES)) {
[01:29:27.093]                   name <- changed[[kk]]
[01:29:27.093]                   NAME <- NAMES[[kk]]
[01:29:27.093]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.093]                     next
[01:29:27.093]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.093]                 }
[01:29:27.093]                 NAMES <- toupper(added)
[01:29:27.093]                 for (kk in seq_along(NAMES)) {
[01:29:27.093]                   name <- added[[kk]]
[01:29:27.093]                   NAME <- NAMES[[kk]]
[01:29:27.093]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.093]                     next
[01:29:27.093]                   args[[name]] <- ""
[01:29:27.093]                 }
[01:29:27.093]                 NAMES <- toupper(removed)
[01:29:27.093]                 for (kk in seq_along(NAMES)) {
[01:29:27.093]                   name <- removed[[kk]]
[01:29:27.093]                   NAME <- NAMES[[kk]]
[01:29:27.093]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.093]                     next
[01:29:27.093]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.093]                 }
[01:29:27.093]                 if (length(args) > 0) 
[01:29:27.093]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.093]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.093]             }
[01:29:27.093]             else {
[01:29:27.093]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.093]             }
[01:29:27.093]             {
[01:29:27.093]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.093]                   0L) {
[01:29:27.093]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.093]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.093]                   base::options(opts)
[01:29:27.093]                 }
[01:29:27.093]                 {
[01:29:27.093]                   {
[01:29:27.093]                     base::assign(".Random.seed", c(10407L, -1090088410L, 
[01:29:27.093]                     -1005590256L, 316241774L, -589582443L, -318722748L, 
[01:29:27.093]                     -62315152L), envir = base::globalenv(), inherits = FALSE)
[01:29:27.093]                     NULL
[01:29:27.093]                   }
[01:29:27.093]                   options(future.plan = NULL)
[01:29:27.093]                   if (is.na(NA_character_)) 
[01:29:27.093]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.093]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.093]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.093]                   {
[01:29:27.093]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.093]                     if (!future$lazy) 
[01:29:27.093]                       future <- run(future)
[01:29:27.093]                     invisible(future)
[01:29:27.093]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.093]                 }
[01:29:27.093]             }
[01:29:27.093]         }
[01:29:27.093]     })
[01:29:27.093]     if (TRUE) {
[01:29:27.093]         base::sink(type = "output", split = FALSE)
[01:29:27.093]         if (TRUE) {
[01:29:27.093]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.093]         }
[01:29:27.093]         else {
[01:29:27.093]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.093]         }
[01:29:27.093]         base::close(...future.stdout)
[01:29:27.093]         ...future.stdout <- NULL
[01:29:27.093]     }
[01:29:27.093]     ...future.result$conditions <- ...future.conditions
[01:29:27.093]     ...future.result$finished <- base::Sys.time()
[01:29:27.093]     ...future.result
[01:29:27.093] }
[01:29:27.097] assign_globals() ...
[01:29:27.098] List of 1
[01:29:27.098]  $ x: int [1:4] 0 1 2 3
[01:29:27.098]  - attr(*, "where")=List of 1
[01:29:27.098]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.098]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.098]  - attr(*, "resolved")= logi FALSE
[01:29:27.098]  - attr(*, "total_size")= num 64
[01:29:27.098]  - attr(*, "already-done")= logi TRUE
[01:29:27.101] - copied 'x' to environment
[01:29:27.101] assign_globals() ... done
[01:29:27.101] plan(): Setting new future strategy stack:
[01:29:27.101] List of future strategies:
[01:29:27.101] 1. sequential:
[01:29:27.101]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.101]    - tweaked: FALSE
[01:29:27.101]    - call: NULL
[01:29:27.102] plan(): nbrOfWorkers() = 1
[01:29:27.103] plan(): Setting new future strategy stack:
[01:29:27.104] List of future strategies:
[01:29:27.104] 1. sequential:
[01:29:27.104]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.104]    - tweaked: FALSE
[01:29:27.104]    - call: plan(strategy)
[01:29:27.104] plan(): nbrOfWorkers() = 1
[01:29:27.104] SequentialFuture started (and completed)
[01:29:27.105] - Launch lazy future ... done
[01:29:27.105] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_1-988817'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96c7337d0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.106] getGlobalsAndPackages() ...
[01:29:27.106] Searching for globals...
[01:29:27.107] - globals found: [3] '{', 'sample', 'x'
[01:29:27.108] Searching for globals ... DONE
[01:29:27.108] Resolving globals: FALSE
[01:29:27.108] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.109] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.109] - globals: [1] 'x'
[01:29:27.109] 
[01:29:27.109] getGlobalsAndPackages() ... DONE
[01:29:27.110] run() for 'Future' ...
[01:29:27.110] - state: 'created'
[01:29:27.110] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.111] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.111] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.111]   - Field: 'label'
[01:29:27.111]   - Field: 'local'
[01:29:27.112]   - Field: 'owner'
[01:29:27.112]   - Field: 'envir'
[01:29:27.112]   - Field: 'packages'
[01:29:27.112]   - Field: 'gc'
[01:29:27.112]   - Field: 'conditions'
[01:29:27.113]   - Field: 'expr'
[01:29:27.113]   - Field: 'uuid'
[01:29:27.113]   - Field: 'seed'
[01:29:27.113]   - Field: 'version'
[01:29:27.113]   - Field: 'result'
[01:29:27.113]   - Field: 'asynchronous'
[01:29:27.114]   - Field: 'calls'
[01:29:27.114]   - Field: 'globals'
[01:29:27.114]   - Field: 'stdout'
[01:29:27.114]   - Field: 'earlySignal'
[01:29:27.114]   - Field: 'lazy'
[01:29:27.115]   - Field: 'state'
[01:29:27.115] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.115] - Launch lazy future ...
[01:29:27.115] Packages needed by the future expression (n = 0): <none>
[01:29:27.115] Packages needed by future strategies (n = 0): <none>
[01:29:27.116] {
[01:29:27.116]     {
[01:29:27.116]         {
[01:29:27.116]             ...future.startTime <- base::Sys.time()
[01:29:27.116]             {
[01:29:27.116]                 {
[01:29:27.116]                   {
[01:29:27.116]                     base::local({
[01:29:27.116]                       has_future <- base::requireNamespace("future", 
[01:29:27.116]                         quietly = TRUE)
[01:29:27.116]                       if (has_future) {
[01:29:27.116]                         ns <- base::getNamespace("future")
[01:29:27.116]                         version <- ns[[".package"]][["version"]]
[01:29:27.116]                         if (is.null(version)) 
[01:29:27.116]                           version <- utils::packageVersion("future")
[01:29:27.116]                       }
[01:29:27.116]                       else {
[01:29:27.116]                         version <- NULL
[01:29:27.116]                       }
[01:29:27.116]                       if (!has_future || version < "1.8.0") {
[01:29:27.116]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.116]                           "", base::R.version$version.string), 
[01:29:27.116]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.116]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.116]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.116]                             "release", "version")], collapse = " "), 
[01:29:27.116]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.116]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.116]                           info)
[01:29:27.116]                         info <- base::paste(info, collapse = "; ")
[01:29:27.116]                         if (!has_future) {
[01:29:27.116]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.116]                             info)
[01:29:27.116]                         }
[01:29:27.116]                         else {
[01:29:27.116]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.116]                             info, version)
[01:29:27.116]                         }
[01:29:27.116]                         base::stop(msg)
[01:29:27.116]                       }
[01:29:27.116]                     })
[01:29:27.116]                   }
[01:29:27.116]                   options(future.plan = NULL)
[01:29:27.116]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.116]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.116]                 }
[01:29:27.116]                 ...future.workdir <- getwd()
[01:29:27.116]             }
[01:29:27.116]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.116]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.116]         }
[01:29:27.116]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.116]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.116]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.116]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.116]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.116]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.116]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.116]             base::names(...future.oldOptions))
[01:29:27.116]     }
[01:29:27.116]     if (FALSE) {
[01:29:27.116]     }
[01:29:27.116]     else {
[01:29:27.116]         if (TRUE) {
[01:29:27.116]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.116]                 open = "w")
[01:29:27.116]         }
[01:29:27.116]         else {
[01:29:27.116]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.116]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.116]         }
[01:29:27.116]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.116]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.116]             base::sink(type = "output", split = FALSE)
[01:29:27.116]             base::close(...future.stdout)
[01:29:27.116]         }, add = TRUE)
[01:29:27.116]     }
[01:29:27.116]     ...future.frame <- base::sys.nframe()
[01:29:27.116]     ...future.conditions <- base::list()
[01:29:27.116]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.116]     if (FALSE) {
[01:29:27.116]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.116]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.116]     }
[01:29:27.116]     ...future.result <- base::tryCatch({
[01:29:27.116]         base::withCallingHandlers({
[01:29:27.116]             ...future.value <- base::withVisible(base::local({
[01:29:27.116]                 sample(x, size = 1L)
[01:29:27.116]             }))
[01:29:27.116]             future::FutureResult(value = ...future.value$value, 
[01:29:27.116]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.116]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.116]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.116]                     ...future.globalenv.names))
[01:29:27.116]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.116]         }, condition = base::local({
[01:29:27.116]             c <- base::c
[01:29:27.116]             inherits <- base::inherits
[01:29:27.116]             invokeRestart <- base::invokeRestart
[01:29:27.116]             length <- base::length
[01:29:27.116]             list <- base::list
[01:29:27.116]             seq.int <- base::seq.int
[01:29:27.116]             signalCondition <- base::signalCondition
[01:29:27.116]             sys.calls <- base::sys.calls
[01:29:27.116]             `[[` <- base::`[[`
[01:29:27.116]             `+` <- base::`+`
[01:29:27.116]             `<<-` <- base::`<<-`
[01:29:27.116]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.116]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.116]                   3L)]
[01:29:27.116]             }
[01:29:27.116]             function(cond) {
[01:29:27.116]                 is_error <- inherits(cond, "error")
[01:29:27.116]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.116]                   NULL)
[01:29:27.116]                 if (is_error) {
[01:29:27.116]                   sessionInformation <- function() {
[01:29:27.116]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.116]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.116]                       search = base::search(), system = base::Sys.info())
[01:29:27.116]                   }
[01:29:27.116]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.116]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.116]                     cond$call), session = sessionInformation(), 
[01:29:27.116]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.116]                   signalCondition(cond)
[01:29:27.116]                 }
[01:29:27.116]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.116]                 "immediateCondition"))) {
[01:29:27.116]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.116]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.116]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.116]                   if (TRUE && !signal) {
[01:29:27.116]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.116]                     {
[01:29:27.116]                       inherits <- base::inherits
[01:29:27.116]                       invokeRestart <- base::invokeRestart
[01:29:27.116]                       is.null <- base::is.null
[01:29:27.116]                       muffled <- FALSE
[01:29:27.116]                       if (inherits(cond, "message")) {
[01:29:27.116]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.116]                         if (muffled) 
[01:29:27.116]                           invokeRestart("muffleMessage")
[01:29:27.116]                       }
[01:29:27.116]                       else if (inherits(cond, "warning")) {
[01:29:27.116]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.116]                         if (muffled) 
[01:29:27.116]                           invokeRestart("muffleWarning")
[01:29:27.116]                       }
[01:29:27.116]                       else if (inherits(cond, "condition")) {
[01:29:27.116]                         if (!is.null(pattern)) {
[01:29:27.116]                           computeRestarts <- base::computeRestarts
[01:29:27.116]                           grepl <- base::grepl
[01:29:27.116]                           restarts <- computeRestarts(cond)
[01:29:27.116]                           for (restart in restarts) {
[01:29:27.116]                             name <- restart$name
[01:29:27.116]                             if (is.null(name)) 
[01:29:27.116]                               next
[01:29:27.116]                             if (!grepl(pattern, name)) 
[01:29:27.116]                               next
[01:29:27.116]                             invokeRestart(restart)
[01:29:27.116]                             muffled <- TRUE
[01:29:27.116]                             break
[01:29:27.116]                           }
[01:29:27.116]                         }
[01:29:27.116]                       }
[01:29:27.116]                       invisible(muffled)
[01:29:27.116]                     }
[01:29:27.116]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.116]                   }
[01:29:27.116]                 }
[01:29:27.116]                 else {
[01:29:27.116]                   if (TRUE) {
[01:29:27.116]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.116]                     {
[01:29:27.116]                       inherits <- base::inherits
[01:29:27.116]                       invokeRestart <- base::invokeRestart
[01:29:27.116]                       is.null <- base::is.null
[01:29:27.116]                       muffled <- FALSE
[01:29:27.116]                       if (inherits(cond, "message")) {
[01:29:27.116]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.116]                         if (muffled) 
[01:29:27.116]                           invokeRestart("muffleMessage")
[01:29:27.116]                       }
[01:29:27.116]                       else if (inherits(cond, "warning")) {
[01:29:27.116]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.116]                         if (muffled) 
[01:29:27.116]                           invokeRestart("muffleWarning")
[01:29:27.116]                       }
[01:29:27.116]                       else if (inherits(cond, "condition")) {
[01:29:27.116]                         if (!is.null(pattern)) {
[01:29:27.116]                           computeRestarts <- base::computeRestarts
[01:29:27.116]                           grepl <- base::grepl
[01:29:27.116]                           restarts <- computeRestarts(cond)
[01:29:27.116]                           for (restart in restarts) {
[01:29:27.116]                             name <- restart$name
[01:29:27.116]                             if (is.null(name)) 
[01:29:27.116]                               next
[01:29:27.116]                             if (!grepl(pattern, name)) 
[01:29:27.116]                               next
[01:29:27.116]                             invokeRestart(restart)
[01:29:27.116]                             muffled <- TRUE
[01:29:27.116]                             break
[01:29:27.116]                           }
[01:29:27.116]                         }
[01:29:27.116]                       }
[01:29:27.116]                       invisible(muffled)
[01:29:27.116]                     }
[01:29:27.116]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.116]                   }
[01:29:27.116]                 }
[01:29:27.116]             }
[01:29:27.116]         }))
[01:29:27.116]     }, error = function(ex) {
[01:29:27.116]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.116]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.116]                 ...future.rng), started = ...future.startTime, 
[01:29:27.116]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.116]             version = "1.8"), class = "FutureResult")
[01:29:27.116]     }, finally = {
[01:29:27.116]         if (!identical(...future.workdir, getwd())) 
[01:29:27.116]             setwd(...future.workdir)
[01:29:27.116]         {
[01:29:27.116]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.116]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.116]             }
[01:29:27.116]             base::options(...future.oldOptions)
[01:29:27.116]             if (.Platform$OS.type == "windows") {
[01:29:27.116]                 old_names <- names(...future.oldEnvVars)
[01:29:27.116]                 envs <- base::Sys.getenv()
[01:29:27.116]                 names <- names(envs)
[01:29:27.116]                 common <- intersect(names, old_names)
[01:29:27.116]                 added <- setdiff(names, old_names)
[01:29:27.116]                 removed <- setdiff(old_names, names)
[01:29:27.116]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.116]                   envs[common]]
[01:29:27.116]                 NAMES <- toupper(changed)
[01:29:27.116]                 args <- list()
[01:29:27.116]                 for (kk in seq_along(NAMES)) {
[01:29:27.116]                   name <- changed[[kk]]
[01:29:27.116]                   NAME <- NAMES[[kk]]
[01:29:27.116]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.116]                     next
[01:29:27.116]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.116]                 }
[01:29:27.116]                 NAMES <- toupper(added)
[01:29:27.116]                 for (kk in seq_along(NAMES)) {
[01:29:27.116]                   name <- added[[kk]]
[01:29:27.116]                   NAME <- NAMES[[kk]]
[01:29:27.116]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.116]                     next
[01:29:27.116]                   args[[name]] <- ""
[01:29:27.116]                 }
[01:29:27.116]                 NAMES <- toupper(removed)
[01:29:27.116]                 for (kk in seq_along(NAMES)) {
[01:29:27.116]                   name <- removed[[kk]]
[01:29:27.116]                   NAME <- NAMES[[kk]]
[01:29:27.116]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.116]                     next
[01:29:27.116]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.116]                 }
[01:29:27.116]                 if (length(args) > 0) 
[01:29:27.116]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.116]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.116]             }
[01:29:27.116]             else {
[01:29:27.116]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.116]             }
[01:29:27.116]             {
[01:29:27.116]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.116]                   0L) {
[01:29:27.116]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.116]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.116]                   base::options(opts)
[01:29:27.116]                 }
[01:29:27.116]                 {
[01:29:27.116]                   {
[01:29:27.116]                     base::assign(".Random.seed", c(10407L, 316241774L, 
[01:29:27.116]                     1425292540L, 905681868L, -62315152L, 381699224L, 
[01:29:27.116]                     1276686987L), envir = base::globalenv(), 
[01:29:27.116]                       inherits = FALSE)
[01:29:27.116]                     NULL
[01:29:27.116]                   }
[01:29:27.116]                   options(future.plan = NULL)
[01:29:27.116]                   if (is.na(NA_character_)) 
[01:29:27.116]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.116]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.116]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.116]                   {
[01:29:27.116]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.116]                     if (!future$lazy) 
[01:29:27.116]                       future <- run(future)
[01:29:27.116]                     invisible(future)
[01:29:27.116]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.116]                 }
[01:29:27.116]             }
[01:29:27.116]         }
[01:29:27.116]     })
[01:29:27.116]     if (TRUE) {
[01:29:27.116]         base::sink(type = "output", split = FALSE)
[01:29:27.116]         if (TRUE) {
[01:29:27.116]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.116]         }
[01:29:27.116]         else {
[01:29:27.116]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.116]         }
[01:29:27.116]         base::close(...future.stdout)
[01:29:27.116]         ...future.stdout <- NULL
[01:29:27.116]     }
[01:29:27.116]     ...future.result$conditions <- ...future.conditions
[01:29:27.116]     ...future.result$finished <- base::Sys.time()
[01:29:27.116]     ...future.result
[01:29:27.116] }
[01:29:27.120] assign_globals() ...
[01:29:27.120] List of 1
[01:29:27.120]  $ x: int [1:4] 0 1 2 3
[01:29:27.120]  - attr(*, "where")=List of 1
[01:29:27.120]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.120]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.120]  - attr(*, "resolved")= logi FALSE
[01:29:27.120]  - attr(*, "total_size")= num 64
[01:29:27.120]  - attr(*, "already-done")= logi TRUE
[01:29:27.123] - copied 'x' to environment
[01:29:27.124] assign_globals() ... done
[01:29:27.124] plan(): Setting new future strategy stack:
[01:29:27.124] List of future strategies:
[01:29:27.124] 1. sequential:
[01:29:27.124]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.124]    - tweaked: FALSE
[01:29:27.124]    - call: NULL
[01:29:27.125] plan(): nbrOfWorkers() = 1
[01:29:27.126] plan(): Setting new future strategy stack:
[01:29:27.126] List of future strategies:
[01:29:27.126] 1. sequential:
[01:29:27.126]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.126]    - tweaked: FALSE
[01:29:27.126]    - call: plan(strategy)
[01:29:27.129] plan(): nbrOfWorkers() = 1
[01:29:27.129] SequentialFuture started (and completed)
[01:29:27.130] - Launch lazy future ... done
[01:29:27.130] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_2-256483'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96c7337d0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.131] getGlobalsAndPackages() ...
[01:29:27.131] Searching for globals...
[01:29:27.132] - globals found: [3] '{', 'sample', 'x'
[01:29:27.133] Searching for globals ... DONE
[01:29:27.133] Resolving globals: FALSE
[01:29:27.133] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.134] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.134] - globals: [1] 'x'
[01:29:27.134] 
[01:29:27.134] getGlobalsAndPackages() ... DONE
[01:29:27.135] run() for 'Future' ...
[01:29:27.135] - state: 'created'
[01:29:27.135] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.136] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.136] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.136]   - Field: 'label'
[01:29:27.136]   - Field: 'local'
[01:29:27.136]   - Field: 'owner'
[01:29:27.137]   - Field: 'envir'
[01:29:27.137]   - Field: 'packages'
[01:29:27.137]   - Field: 'gc'
[01:29:27.137]   - Field: 'conditions'
[01:29:27.137]   - Field: 'expr'
[01:29:27.137]   - Field: 'uuid'
[01:29:27.138]   - Field: 'seed'
[01:29:27.138]   - Field: 'version'
[01:29:27.138]   - Field: 'result'
[01:29:27.138]   - Field: 'asynchronous'
[01:29:27.138]   - Field: 'calls'
[01:29:27.139]   - Field: 'globals'
[01:29:27.139]   - Field: 'stdout'
[01:29:27.139]   - Field: 'earlySignal'
[01:29:27.139]   - Field: 'lazy'
[01:29:27.139]   - Field: 'state'
[01:29:27.139] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.140] - Launch lazy future ...
[01:29:27.140] Packages needed by the future expression (n = 0): <none>
[01:29:27.140] Packages needed by future strategies (n = 0): <none>
[01:29:27.141] {
[01:29:27.141]     {
[01:29:27.141]         {
[01:29:27.141]             ...future.startTime <- base::Sys.time()
[01:29:27.141]             {
[01:29:27.141]                 {
[01:29:27.141]                   {
[01:29:27.141]                     base::local({
[01:29:27.141]                       has_future <- base::requireNamespace("future", 
[01:29:27.141]                         quietly = TRUE)
[01:29:27.141]                       if (has_future) {
[01:29:27.141]                         ns <- base::getNamespace("future")
[01:29:27.141]                         version <- ns[[".package"]][["version"]]
[01:29:27.141]                         if (is.null(version)) 
[01:29:27.141]                           version <- utils::packageVersion("future")
[01:29:27.141]                       }
[01:29:27.141]                       else {
[01:29:27.141]                         version <- NULL
[01:29:27.141]                       }
[01:29:27.141]                       if (!has_future || version < "1.8.0") {
[01:29:27.141]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.141]                           "", base::R.version$version.string), 
[01:29:27.141]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.141]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.141]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.141]                             "release", "version")], collapse = " "), 
[01:29:27.141]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.141]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.141]                           info)
[01:29:27.141]                         info <- base::paste(info, collapse = "; ")
[01:29:27.141]                         if (!has_future) {
[01:29:27.141]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.141]                             info)
[01:29:27.141]                         }
[01:29:27.141]                         else {
[01:29:27.141]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.141]                             info, version)
[01:29:27.141]                         }
[01:29:27.141]                         base::stop(msg)
[01:29:27.141]                       }
[01:29:27.141]                     })
[01:29:27.141]                   }
[01:29:27.141]                   options(future.plan = NULL)
[01:29:27.141]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.141]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.141]                 }
[01:29:27.141]                 ...future.workdir <- getwd()
[01:29:27.141]             }
[01:29:27.141]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.141]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.141]         }
[01:29:27.141]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.141]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.141]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.141]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.141]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.141]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.141]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.141]             base::names(...future.oldOptions))
[01:29:27.141]     }
[01:29:27.141]     if (FALSE) {
[01:29:27.141]     }
[01:29:27.141]     else {
[01:29:27.141]         if (TRUE) {
[01:29:27.141]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.141]                 open = "w")
[01:29:27.141]         }
[01:29:27.141]         else {
[01:29:27.141]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.141]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.141]         }
[01:29:27.141]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.141]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.141]             base::sink(type = "output", split = FALSE)
[01:29:27.141]             base::close(...future.stdout)
[01:29:27.141]         }, add = TRUE)
[01:29:27.141]     }
[01:29:27.141]     ...future.frame <- base::sys.nframe()
[01:29:27.141]     ...future.conditions <- base::list()
[01:29:27.141]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.141]     if (FALSE) {
[01:29:27.141]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.141]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.141]     }
[01:29:27.141]     ...future.result <- base::tryCatch({
[01:29:27.141]         base::withCallingHandlers({
[01:29:27.141]             ...future.value <- base::withVisible(base::local({
[01:29:27.141]                 sample(x, size = 1L)
[01:29:27.141]             }))
[01:29:27.141]             future::FutureResult(value = ...future.value$value, 
[01:29:27.141]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.141]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.141]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.141]                     ...future.globalenv.names))
[01:29:27.141]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.141]         }, condition = base::local({
[01:29:27.141]             c <- base::c
[01:29:27.141]             inherits <- base::inherits
[01:29:27.141]             invokeRestart <- base::invokeRestart
[01:29:27.141]             length <- base::length
[01:29:27.141]             list <- base::list
[01:29:27.141]             seq.int <- base::seq.int
[01:29:27.141]             signalCondition <- base::signalCondition
[01:29:27.141]             sys.calls <- base::sys.calls
[01:29:27.141]             `[[` <- base::`[[`
[01:29:27.141]             `+` <- base::`+`
[01:29:27.141]             `<<-` <- base::`<<-`
[01:29:27.141]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.141]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.141]                   3L)]
[01:29:27.141]             }
[01:29:27.141]             function(cond) {
[01:29:27.141]                 is_error <- inherits(cond, "error")
[01:29:27.141]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.141]                   NULL)
[01:29:27.141]                 if (is_error) {
[01:29:27.141]                   sessionInformation <- function() {
[01:29:27.141]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.141]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.141]                       search = base::search(), system = base::Sys.info())
[01:29:27.141]                   }
[01:29:27.141]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.141]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.141]                     cond$call), session = sessionInformation(), 
[01:29:27.141]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.141]                   signalCondition(cond)
[01:29:27.141]                 }
[01:29:27.141]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.141]                 "immediateCondition"))) {
[01:29:27.141]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.141]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.141]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.141]                   if (TRUE && !signal) {
[01:29:27.141]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.141]                     {
[01:29:27.141]                       inherits <- base::inherits
[01:29:27.141]                       invokeRestart <- base::invokeRestart
[01:29:27.141]                       is.null <- base::is.null
[01:29:27.141]                       muffled <- FALSE
[01:29:27.141]                       if (inherits(cond, "message")) {
[01:29:27.141]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.141]                         if (muffled) 
[01:29:27.141]                           invokeRestart("muffleMessage")
[01:29:27.141]                       }
[01:29:27.141]                       else if (inherits(cond, "warning")) {
[01:29:27.141]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.141]                         if (muffled) 
[01:29:27.141]                           invokeRestart("muffleWarning")
[01:29:27.141]                       }
[01:29:27.141]                       else if (inherits(cond, "condition")) {
[01:29:27.141]                         if (!is.null(pattern)) {
[01:29:27.141]                           computeRestarts <- base::computeRestarts
[01:29:27.141]                           grepl <- base::grepl
[01:29:27.141]                           restarts <- computeRestarts(cond)
[01:29:27.141]                           for (restart in restarts) {
[01:29:27.141]                             name <- restart$name
[01:29:27.141]                             if (is.null(name)) 
[01:29:27.141]                               next
[01:29:27.141]                             if (!grepl(pattern, name)) 
[01:29:27.141]                               next
[01:29:27.141]                             invokeRestart(restart)
[01:29:27.141]                             muffled <- TRUE
[01:29:27.141]                             break
[01:29:27.141]                           }
[01:29:27.141]                         }
[01:29:27.141]                       }
[01:29:27.141]                       invisible(muffled)
[01:29:27.141]                     }
[01:29:27.141]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.141]                   }
[01:29:27.141]                 }
[01:29:27.141]                 else {
[01:29:27.141]                   if (TRUE) {
[01:29:27.141]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.141]                     {
[01:29:27.141]                       inherits <- base::inherits
[01:29:27.141]                       invokeRestart <- base::invokeRestart
[01:29:27.141]                       is.null <- base::is.null
[01:29:27.141]                       muffled <- FALSE
[01:29:27.141]                       if (inherits(cond, "message")) {
[01:29:27.141]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.141]                         if (muffled) 
[01:29:27.141]                           invokeRestart("muffleMessage")
[01:29:27.141]                       }
[01:29:27.141]                       else if (inherits(cond, "warning")) {
[01:29:27.141]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.141]                         if (muffled) 
[01:29:27.141]                           invokeRestart("muffleWarning")
[01:29:27.141]                       }
[01:29:27.141]                       else if (inherits(cond, "condition")) {
[01:29:27.141]                         if (!is.null(pattern)) {
[01:29:27.141]                           computeRestarts <- base::computeRestarts
[01:29:27.141]                           grepl <- base::grepl
[01:29:27.141]                           restarts <- computeRestarts(cond)
[01:29:27.141]                           for (restart in restarts) {
[01:29:27.141]                             name <- restart$name
[01:29:27.141]                             if (is.null(name)) 
[01:29:27.141]                               next
[01:29:27.141]                             if (!grepl(pattern, name)) 
[01:29:27.141]                               next
[01:29:27.141]                             invokeRestart(restart)
[01:29:27.141]                             muffled <- TRUE
[01:29:27.141]                             break
[01:29:27.141]                           }
[01:29:27.141]                         }
[01:29:27.141]                       }
[01:29:27.141]                       invisible(muffled)
[01:29:27.141]                     }
[01:29:27.141]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.141]                   }
[01:29:27.141]                 }
[01:29:27.141]             }
[01:29:27.141]         }))
[01:29:27.141]     }, error = function(ex) {
[01:29:27.141]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.141]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.141]                 ...future.rng), started = ...future.startTime, 
[01:29:27.141]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.141]             version = "1.8"), class = "FutureResult")
[01:29:27.141]     }, finally = {
[01:29:27.141]         if (!identical(...future.workdir, getwd())) 
[01:29:27.141]             setwd(...future.workdir)
[01:29:27.141]         {
[01:29:27.141]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.141]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.141]             }
[01:29:27.141]             base::options(...future.oldOptions)
[01:29:27.141]             if (.Platform$OS.type == "windows") {
[01:29:27.141]                 old_names <- names(...future.oldEnvVars)
[01:29:27.141]                 envs <- base::Sys.getenv()
[01:29:27.141]                 names <- names(envs)
[01:29:27.141]                 common <- intersect(names, old_names)
[01:29:27.141]                 added <- setdiff(names, old_names)
[01:29:27.141]                 removed <- setdiff(old_names, names)
[01:29:27.141]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.141]                   envs[common]]
[01:29:27.141]                 NAMES <- toupper(changed)
[01:29:27.141]                 args <- list()
[01:29:27.141]                 for (kk in seq_along(NAMES)) {
[01:29:27.141]                   name <- changed[[kk]]
[01:29:27.141]                   NAME <- NAMES[[kk]]
[01:29:27.141]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.141]                     next
[01:29:27.141]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.141]                 }
[01:29:27.141]                 NAMES <- toupper(added)
[01:29:27.141]                 for (kk in seq_along(NAMES)) {
[01:29:27.141]                   name <- added[[kk]]
[01:29:27.141]                   NAME <- NAMES[[kk]]
[01:29:27.141]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.141]                     next
[01:29:27.141]                   args[[name]] <- ""
[01:29:27.141]                 }
[01:29:27.141]                 NAMES <- toupper(removed)
[01:29:27.141]                 for (kk in seq_along(NAMES)) {
[01:29:27.141]                   name <- removed[[kk]]
[01:29:27.141]                   NAME <- NAMES[[kk]]
[01:29:27.141]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.141]                     next
[01:29:27.141]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.141]                 }
[01:29:27.141]                 if (length(args) > 0) 
[01:29:27.141]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.141]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.141]             }
[01:29:27.141]             else {
[01:29:27.141]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.141]             }
[01:29:27.141]             {
[01:29:27.141]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.141]                   0L) {
[01:29:27.141]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.141]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.141]                   base::options(opts)
[01:29:27.141]                 }
[01:29:27.141]                 {
[01:29:27.141]                   {
[01:29:27.141]                     base::assign(".Random.seed", c(10407L, 332331236L, 
[01:29:27.141]                     -1265839190L, -138661437L, -1350006441L, 
[01:29:27.141]                     515236994L, 647840892L), envir = base::globalenv(), 
[01:29:27.141]                       inherits = FALSE)
[01:29:27.141]                     NULL
[01:29:27.141]                   }
[01:29:27.141]                   options(future.plan = NULL)
[01:29:27.141]                   if (is.na(NA_character_)) 
[01:29:27.141]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.141]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.141]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.141]                   {
[01:29:27.141]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.141]                     if (!future$lazy) 
[01:29:27.141]                       future <- run(future)
[01:29:27.141]                     invisible(future)
[01:29:27.141]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.141]                 }
[01:29:27.141]             }
[01:29:27.141]         }
[01:29:27.141]     })
[01:29:27.141]     if (TRUE) {
[01:29:27.141]         base::sink(type = "output", split = FALSE)
[01:29:27.141]         if (TRUE) {
[01:29:27.141]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.141]         }
[01:29:27.141]         else {
[01:29:27.141]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.141]         }
[01:29:27.141]         base::close(...future.stdout)
[01:29:27.141]         ...future.stdout <- NULL
[01:29:27.141]     }
[01:29:27.141]     ...future.result$conditions <- ...future.conditions
[01:29:27.141]     ...future.result$finished <- base::Sys.time()
[01:29:27.141]     ...future.result
[01:29:27.141] }
[01:29:27.145] assign_globals() ...
[01:29:27.145] List of 1
[01:29:27.145]  $ x: int [1:4] 0 1 2 3
[01:29:27.145]  - attr(*, "where")=List of 1
[01:29:27.145]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.145]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.145]  - attr(*, "resolved")= logi FALSE
[01:29:27.145]  - attr(*, "total_size")= num 64
[01:29:27.145]  - attr(*, "already-done")= logi TRUE
[01:29:27.148] - copied 'x' to environment
[01:29:27.148] assign_globals() ... done
[01:29:27.149] plan(): Setting new future strategy stack:
[01:29:27.149] List of future strategies:
[01:29:27.149] 1. sequential:
[01:29:27.149]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.149]    - tweaked: FALSE
[01:29:27.149]    - call: NULL
[01:29:27.150] plan(): nbrOfWorkers() = 1
[01:29:27.151] plan(): Setting new future strategy stack:
[01:29:27.151] List of future strategies:
[01:29:27.151] 1. sequential:
[01:29:27.151]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.151]    - tweaked: FALSE
[01:29:27.151]    - call: plan(strategy)
[01:29:27.152] plan(): nbrOfWorkers() = 1
[01:29:27.152] SequentialFuture started (and completed)
[01:29:27.152] - Launch lazy future ... done
[01:29:27.152] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_3-446751'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96c7337d0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.153] getGlobalsAndPackages() ...
[01:29:27.153] Searching for globals...
[01:29:27.155] - globals found: [3] '{', 'sample', 'x'
[01:29:27.155] Searching for globals ... DONE
[01:29:27.155] Resolving globals: FALSE
[01:29:27.156] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.156] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.156] - globals: [1] 'x'
[01:29:27.156] 
[01:29:27.157] getGlobalsAndPackages() ... DONE
[01:29:27.157] run() for 'Future' ...
[01:29:27.157] - state: 'created'
[01:29:27.157] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.158] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.158] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.158]   - Field: 'label'
[01:29:27.158]   - Field: 'local'
[01:29:27.159]   - Field: 'owner'
[01:29:27.159]   - Field: 'envir'
[01:29:27.159]   - Field: 'packages'
[01:29:27.159]   - Field: 'gc'
[01:29:27.159]   - Field: 'conditions'
[01:29:27.159]   - Field: 'expr'
[01:29:27.160]   - Field: 'uuid'
[01:29:27.160]   - Field: 'seed'
[01:29:27.160]   - Field: 'version'
[01:29:27.160]   - Field: 'result'
[01:29:27.160]   - Field: 'asynchronous'
[01:29:27.161]   - Field: 'calls'
[01:29:27.161]   - Field: 'globals'
[01:29:27.161]   - Field: 'stdout'
[01:29:27.161]   - Field: 'earlySignal'
[01:29:27.163]   - Field: 'lazy'
[01:29:27.163]   - Field: 'state'
[01:29:27.163] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.164] - Launch lazy future ...
[01:29:27.164] Packages needed by the future expression (n = 0): <none>
[01:29:27.164] Packages needed by future strategies (n = 0): <none>
[01:29:27.165] {
[01:29:27.165]     {
[01:29:27.165]         {
[01:29:27.165]             ...future.startTime <- base::Sys.time()
[01:29:27.165]             {
[01:29:27.165]                 {
[01:29:27.165]                   {
[01:29:27.165]                     base::local({
[01:29:27.165]                       has_future <- base::requireNamespace("future", 
[01:29:27.165]                         quietly = TRUE)
[01:29:27.165]                       if (has_future) {
[01:29:27.165]                         ns <- base::getNamespace("future")
[01:29:27.165]                         version <- ns[[".package"]][["version"]]
[01:29:27.165]                         if (is.null(version)) 
[01:29:27.165]                           version <- utils::packageVersion("future")
[01:29:27.165]                       }
[01:29:27.165]                       else {
[01:29:27.165]                         version <- NULL
[01:29:27.165]                       }
[01:29:27.165]                       if (!has_future || version < "1.8.0") {
[01:29:27.165]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.165]                           "", base::R.version$version.string), 
[01:29:27.165]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.165]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.165]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.165]                             "release", "version")], collapse = " "), 
[01:29:27.165]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.165]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.165]                           info)
[01:29:27.165]                         info <- base::paste(info, collapse = "; ")
[01:29:27.165]                         if (!has_future) {
[01:29:27.165]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.165]                             info)
[01:29:27.165]                         }
[01:29:27.165]                         else {
[01:29:27.165]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.165]                             info, version)
[01:29:27.165]                         }
[01:29:27.165]                         base::stop(msg)
[01:29:27.165]                       }
[01:29:27.165]                     })
[01:29:27.165]                   }
[01:29:27.165]                   options(future.plan = NULL)
[01:29:27.165]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.165]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.165]                 }
[01:29:27.165]                 ...future.workdir <- getwd()
[01:29:27.165]             }
[01:29:27.165]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.165]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.165]         }
[01:29:27.165]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.165]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.165]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.165]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.165]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.165]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.165]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.165]             base::names(...future.oldOptions))
[01:29:27.165]     }
[01:29:27.165]     if (FALSE) {
[01:29:27.165]     }
[01:29:27.165]     else {
[01:29:27.165]         if (TRUE) {
[01:29:27.165]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.165]                 open = "w")
[01:29:27.165]         }
[01:29:27.165]         else {
[01:29:27.165]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.165]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.165]         }
[01:29:27.165]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.165]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.165]             base::sink(type = "output", split = FALSE)
[01:29:27.165]             base::close(...future.stdout)
[01:29:27.165]         }, add = TRUE)
[01:29:27.165]     }
[01:29:27.165]     ...future.frame <- base::sys.nframe()
[01:29:27.165]     ...future.conditions <- base::list()
[01:29:27.165]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.165]     if (FALSE) {
[01:29:27.165]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.165]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.165]     }
[01:29:27.165]     ...future.result <- base::tryCatch({
[01:29:27.165]         base::withCallingHandlers({
[01:29:27.165]             ...future.value <- base::withVisible(base::local({
[01:29:27.165]                 sample(x, size = 1L)
[01:29:27.165]             }))
[01:29:27.165]             future::FutureResult(value = ...future.value$value, 
[01:29:27.165]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.165]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.165]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.165]                     ...future.globalenv.names))
[01:29:27.165]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.165]         }, condition = base::local({
[01:29:27.165]             c <- base::c
[01:29:27.165]             inherits <- base::inherits
[01:29:27.165]             invokeRestart <- base::invokeRestart
[01:29:27.165]             length <- base::length
[01:29:27.165]             list <- base::list
[01:29:27.165]             seq.int <- base::seq.int
[01:29:27.165]             signalCondition <- base::signalCondition
[01:29:27.165]             sys.calls <- base::sys.calls
[01:29:27.165]             `[[` <- base::`[[`
[01:29:27.165]             `+` <- base::`+`
[01:29:27.165]             `<<-` <- base::`<<-`
[01:29:27.165]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.165]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.165]                   3L)]
[01:29:27.165]             }
[01:29:27.165]             function(cond) {
[01:29:27.165]                 is_error <- inherits(cond, "error")
[01:29:27.165]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.165]                   NULL)
[01:29:27.165]                 if (is_error) {
[01:29:27.165]                   sessionInformation <- function() {
[01:29:27.165]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.165]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.165]                       search = base::search(), system = base::Sys.info())
[01:29:27.165]                   }
[01:29:27.165]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.165]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.165]                     cond$call), session = sessionInformation(), 
[01:29:27.165]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.165]                   signalCondition(cond)
[01:29:27.165]                 }
[01:29:27.165]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.165]                 "immediateCondition"))) {
[01:29:27.165]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.165]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.165]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.165]                   if (TRUE && !signal) {
[01:29:27.165]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.165]                     {
[01:29:27.165]                       inherits <- base::inherits
[01:29:27.165]                       invokeRestart <- base::invokeRestart
[01:29:27.165]                       is.null <- base::is.null
[01:29:27.165]                       muffled <- FALSE
[01:29:27.165]                       if (inherits(cond, "message")) {
[01:29:27.165]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.165]                         if (muffled) 
[01:29:27.165]                           invokeRestart("muffleMessage")
[01:29:27.165]                       }
[01:29:27.165]                       else if (inherits(cond, "warning")) {
[01:29:27.165]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.165]                         if (muffled) 
[01:29:27.165]                           invokeRestart("muffleWarning")
[01:29:27.165]                       }
[01:29:27.165]                       else if (inherits(cond, "condition")) {
[01:29:27.165]                         if (!is.null(pattern)) {
[01:29:27.165]                           computeRestarts <- base::computeRestarts
[01:29:27.165]                           grepl <- base::grepl
[01:29:27.165]                           restarts <- computeRestarts(cond)
[01:29:27.165]                           for (restart in restarts) {
[01:29:27.165]                             name <- restart$name
[01:29:27.165]                             if (is.null(name)) 
[01:29:27.165]                               next
[01:29:27.165]                             if (!grepl(pattern, name)) 
[01:29:27.165]                               next
[01:29:27.165]                             invokeRestart(restart)
[01:29:27.165]                             muffled <- TRUE
[01:29:27.165]                             break
[01:29:27.165]                           }
[01:29:27.165]                         }
[01:29:27.165]                       }
[01:29:27.165]                       invisible(muffled)
[01:29:27.165]                     }
[01:29:27.165]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.165]                   }
[01:29:27.165]                 }
[01:29:27.165]                 else {
[01:29:27.165]                   if (TRUE) {
[01:29:27.165]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.165]                     {
[01:29:27.165]                       inherits <- base::inherits
[01:29:27.165]                       invokeRestart <- base::invokeRestart
[01:29:27.165]                       is.null <- base::is.null
[01:29:27.165]                       muffled <- FALSE
[01:29:27.165]                       if (inherits(cond, "message")) {
[01:29:27.165]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.165]                         if (muffled) 
[01:29:27.165]                           invokeRestart("muffleMessage")
[01:29:27.165]                       }
[01:29:27.165]                       else if (inherits(cond, "warning")) {
[01:29:27.165]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.165]                         if (muffled) 
[01:29:27.165]                           invokeRestart("muffleWarning")
[01:29:27.165]                       }
[01:29:27.165]                       else if (inherits(cond, "condition")) {
[01:29:27.165]                         if (!is.null(pattern)) {
[01:29:27.165]                           computeRestarts <- base::computeRestarts
[01:29:27.165]                           grepl <- base::grepl
[01:29:27.165]                           restarts <- computeRestarts(cond)
[01:29:27.165]                           for (restart in restarts) {
[01:29:27.165]                             name <- restart$name
[01:29:27.165]                             if (is.null(name)) 
[01:29:27.165]                               next
[01:29:27.165]                             if (!grepl(pattern, name)) 
[01:29:27.165]                               next
[01:29:27.165]                             invokeRestart(restart)
[01:29:27.165]                             muffled <- TRUE
[01:29:27.165]                             break
[01:29:27.165]                           }
[01:29:27.165]                         }
[01:29:27.165]                       }
[01:29:27.165]                       invisible(muffled)
[01:29:27.165]                     }
[01:29:27.165]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.165]                   }
[01:29:27.165]                 }
[01:29:27.165]             }
[01:29:27.165]         }))
[01:29:27.165]     }, error = function(ex) {
[01:29:27.165]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.165]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.165]                 ...future.rng), started = ...future.startTime, 
[01:29:27.165]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.165]             version = "1.8"), class = "FutureResult")
[01:29:27.165]     }, finally = {
[01:29:27.165]         if (!identical(...future.workdir, getwd())) 
[01:29:27.165]             setwd(...future.workdir)
[01:29:27.165]         {
[01:29:27.165]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.165]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.165]             }
[01:29:27.165]             base::options(...future.oldOptions)
[01:29:27.165]             if (.Platform$OS.type == "windows") {
[01:29:27.165]                 old_names <- names(...future.oldEnvVars)
[01:29:27.165]                 envs <- base::Sys.getenv()
[01:29:27.165]                 names <- names(envs)
[01:29:27.165]                 common <- intersect(names, old_names)
[01:29:27.165]                 added <- setdiff(names, old_names)
[01:29:27.165]                 removed <- setdiff(old_names, names)
[01:29:27.165]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.165]                   envs[common]]
[01:29:27.165]                 NAMES <- toupper(changed)
[01:29:27.165]                 args <- list()
[01:29:27.165]                 for (kk in seq_along(NAMES)) {
[01:29:27.165]                   name <- changed[[kk]]
[01:29:27.165]                   NAME <- NAMES[[kk]]
[01:29:27.165]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.165]                     next
[01:29:27.165]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.165]                 }
[01:29:27.165]                 NAMES <- toupper(added)
[01:29:27.165]                 for (kk in seq_along(NAMES)) {
[01:29:27.165]                   name <- added[[kk]]
[01:29:27.165]                   NAME <- NAMES[[kk]]
[01:29:27.165]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.165]                     next
[01:29:27.165]                   args[[name]] <- ""
[01:29:27.165]                 }
[01:29:27.165]                 NAMES <- toupper(removed)
[01:29:27.165]                 for (kk in seq_along(NAMES)) {
[01:29:27.165]                   name <- removed[[kk]]
[01:29:27.165]                   NAME <- NAMES[[kk]]
[01:29:27.165]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.165]                     next
[01:29:27.165]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.165]                 }
[01:29:27.165]                 if (length(args) > 0) 
[01:29:27.165]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.165]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.165]             }
[01:29:27.165]             else {
[01:29:27.165]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.165]             }
[01:29:27.165]             {
[01:29:27.165]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.165]                   0L) {
[01:29:27.165]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.165]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.165]                   base::options(opts)
[01:29:27.165]                 }
[01:29:27.165]                 {
[01:29:27.165]                   {
[01:29:27.165]                     base::assign(".Random.seed", c(10407L, -138661437L, 
[01:29:27.165]                     -1310103936L, -1203097004L, 647840892L, 1770118238L, 
[01:29:27.165]                     858550343L), envir = base::globalenv(), inherits = FALSE)
[01:29:27.165]                     NULL
[01:29:27.165]                   }
[01:29:27.165]                   options(future.plan = NULL)
[01:29:27.165]                   if (is.na(NA_character_)) 
[01:29:27.165]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.165]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.165]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.165]                   {
[01:29:27.165]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.165]                     if (!future$lazy) 
[01:29:27.165]                       future <- run(future)
[01:29:27.165]                     invisible(future)
[01:29:27.165]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.165]                 }
[01:29:27.165]             }
[01:29:27.165]         }
[01:29:27.165]     })
[01:29:27.165]     if (TRUE) {
[01:29:27.165]         base::sink(type = "output", split = FALSE)
[01:29:27.165]         if (TRUE) {
[01:29:27.165]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.165]         }
[01:29:27.165]         else {
[01:29:27.165]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.165]         }
[01:29:27.165]         base::close(...future.stdout)
[01:29:27.165]         ...future.stdout <- NULL
[01:29:27.165]     }
[01:29:27.165]     ...future.result$conditions <- ...future.conditions
[01:29:27.165]     ...future.result$finished <- base::Sys.time()
[01:29:27.165]     ...future.result
[01:29:27.165] }
[01:29:27.168] assign_globals() ...
[01:29:27.169] List of 1
[01:29:27.169]  $ x: int [1:4] 0 1 2 3
[01:29:27.169]  - attr(*, "where")=List of 1
[01:29:27.169]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.169]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.169]  - attr(*, "resolved")= logi FALSE
[01:29:27.169]  - attr(*, "total_size")= num 64
[01:29:27.169]  - attr(*, "already-done")= logi TRUE
[01:29:27.172] - copied 'x' to environment
[01:29:27.172] assign_globals() ... done
[01:29:27.172] plan(): Setting new future strategy stack:
[01:29:27.172] List of future strategies:
[01:29:27.172] 1. sequential:
[01:29:27.172]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.172]    - tweaked: FALSE
[01:29:27.172]    - call: NULL
[01:29:27.173] plan(): nbrOfWorkers() = 1
[01:29:27.174] plan(): Setting new future strategy stack:
[01:29:27.174] List of future strategies:
[01:29:27.174] 1. sequential:
[01:29:27.174]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.174]    - tweaked: FALSE
[01:29:27.174]    - call: plan(strategy)
[01:29:27.175] plan(): nbrOfWorkers() = 1
[01:29:27.175] SequentialFuture started (and completed)
[01:29:27.176] - Launch lazy future ... done
[01:29:27.176] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_4-492830'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96c7337d0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.177] resolve() on list ...
[01:29:27.177]  recursive: 0
[01:29:27.177]  length: 4
[01:29:27.177] 
[01:29:27.178] resolved() for 'SequentialFuture' ...
[01:29:27.178] - state: 'finished'
[01:29:27.178] - run: TRUE
[01:29:27.178] - result: 'FutureResult'
[01:29:27.178] resolved() for 'SequentialFuture' ... done
[01:29:27.179] Future #1
[01:29:27.179] signalConditionsASAP(SequentialFuture, pos=1) ...
[01:29:27.179] - nx: 4
[01:29:27.179] - relay: TRUE
[01:29:27.179] - stdout: TRUE
[01:29:27.179] - signal: TRUE
[01:29:27.180] - resignal: FALSE
[01:29:27.180] - force: TRUE
[01:29:27.180] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:27.180] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:27.180]  - until=1
[01:29:27.180]  - relaying element #1
[01:29:27.181] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:27.181] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:27.181] signalConditionsASAP(SequentialFuture, pos=1) ... done
[01:29:27.181]  length: 3 (resolved future 1)
[01:29:27.181] resolved() for 'SequentialFuture' ...
[01:29:27.182] - state: 'finished'
[01:29:27.182] - run: TRUE
[01:29:27.182] - result: 'FutureResult'
[01:29:27.182] resolved() for 'SequentialFuture' ... done
[01:29:27.182] Future #2
[01:29:27.183] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:29:27.183] - nx: 4
[01:29:27.183] - relay: TRUE
[01:29:27.183] - stdout: TRUE
[01:29:27.183] - signal: TRUE
[01:29:27.183] - resignal: FALSE
[01:29:27.183] - force: TRUE
[01:29:27.184] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:27.184] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:27.184]  - until=2
[01:29:27.184]  - relaying element #2
[01:29:27.184] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:27.185] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:27.185] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:29:27.185]  length: 2 (resolved future 2)
[01:29:27.185] resolved() for 'SequentialFuture' ...
[01:29:27.185] - state: 'finished'
[01:29:27.185] - run: TRUE
[01:29:27.186] - result: 'FutureResult'
[01:29:27.186] resolved() for 'SequentialFuture' ... done
[01:29:27.186] Future #3
[01:29:27.186] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:29:27.186] - nx: 4
[01:29:27.187] - relay: TRUE
[01:29:27.187] - stdout: TRUE
[01:29:27.187] - signal: TRUE
[01:29:27.187] - resignal: FALSE
[01:29:27.187] - force: TRUE
[01:29:27.187] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:27.187] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:27.188]  - until=3
[01:29:27.188]  - relaying element #3
[01:29:27.188] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:27.188] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:27.188] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:29:27.189]  length: 1 (resolved future 3)
[01:29:27.189] resolved() for 'SequentialFuture' ...
[01:29:27.189] - state: 'finished'
[01:29:27.189] - run: TRUE
[01:29:27.189] - result: 'FutureResult'
[01:29:27.190] resolved() for 'SequentialFuture' ... done
[01:29:27.190] Future #4
[01:29:27.190] signalConditionsASAP(SequentialFuture, pos=4) ...
[01:29:27.190] - nx: 4
[01:29:27.190] - relay: TRUE
[01:29:27.191] - stdout: TRUE
[01:29:27.191] - signal: TRUE
[01:29:27.191] - resignal: FALSE
[01:29:27.191] - force: TRUE
[01:29:27.191] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:27.191] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:27.191]  - until=4
[01:29:27.192]  - relaying element #4
[01:29:27.192] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.192] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.192] signalConditionsASAP(SequentialFuture, pos=4) ... done
[01:29:27.192]  length: 0 (resolved future 4)
[01:29:27.193] Relaying remaining futures
[01:29:27.193] signalConditionsASAP(NULL, pos=0) ...
[01:29:27.193] - nx: 4
[01:29:27.193] - relay: TRUE
[01:29:27.193] - stdout: TRUE
[01:29:27.193] - signal: TRUE
[01:29:27.194] - resignal: FALSE
[01:29:27.194] - force: TRUE
[01:29:27.194] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.194] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[01:29:27.194] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.195] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.195] signalConditionsASAP(NULL, pos=0) ... done
[01:29:27.195] resolve() on list ... DONE
[[1]]
[1] 3

[[2]]
[1] 3

[[3]]
[1] 3

[[4]]
[1] 2

[01:29:27.282] getGlobalsAndPackages() ...
[01:29:27.282] Searching for globals...
[01:29:27.285] - globals found: [3] '{', 'sample', 'x'
[01:29:27.285] Searching for globals ... DONE
[01:29:27.285] Resolving globals: FALSE
[01:29:27.286] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.286] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.287] - globals: [1] 'x'
[01:29:27.287] 
[01:29:27.287] getGlobalsAndPackages() ... DONE
[01:29:27.287] run() for 'Future' ...
[01:29:27.288] - state: 'created'
[01:29:27.288] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.288] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.289] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.289]   - Field: 'label'
[01:29:27.289]   - Field: 'local'
[01:29:27.289]   - Field: 'owner'
[01:29:27.289]   - Field: 'envir'
[01:29:27.290]   - Field: 'packages'
[01:29:27.290]   - Field: 'gc'
[01:29:27.290]   - Field: 'conditions'
[01:29:27.290]   - Field: 'expr'
[01:29:27.290]   - Field: 'uuid'
[01:29:27.290]   - Field: 'seed'
[01:29:27.291]   - Field: 'version'
[01:29:27.291]   - Field: 'result'
[01:29:27.291]   - Field: 'asynchronous'
[01:29:27.291]   - Field: 'calls'
[01:29:27.291]   - Field: 'globals'
[01:29:27.292]   - Field: 'stdout'
[01:29:27.292]   - Field: 'earlySignal'
[01:29:27.292]   - Field: 'lazy'
[01:29:27.292]   - Field: 'state'
[01:29:27.292] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.293] - Launch lazy future ...
[01:29:27.293] Packages needed by the future expression (n = 0): <none>
[01:29:27.293] Packages needed by future strategies (n = 0): <none>
[01:29:27.294] {
[01:29:27.294]     {
[01:29:27.294]         {
[01:29:27.294]             ...future.startTime <- base::Sys.time()
[01:29:27.294]             {
[01:29:27.294]                 {
[01:29:27.294]                   {
[01:29:27.294]                     base::local({
[01:29:27.294]                       has_future <- base::requireNamespace("future", 
[01:29:27.294]                         quietly = TRUE)
[01:29:27.294]                       if (has_future) {
[01:29:27.294]                         ns <- base::getNamespace("future")
[01:29:27.294]                         version <- ns[[".package"]][["version"]]
[01:29:27.294]                         if (is.null(version)) 
[01:29:27.294]                           version <- utils::packageVersion("future")
[01:29:27.294]                       }
[01:29:27.294]                       else {
[01:29:27.294]                         version <- NULL
[01:29:27.294]                       }
[01:29:27.294]                       if (!has_future || version < "1.8.0") {
[01:29:27.294]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.294]                           "", base::R.version$version.string), 
[01:29:27.294]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.294]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.294]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.294]                             "release", "version")], collapse = " "), 
[01:29:27.294]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.294]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.294]                           info)
[01:29:27.294]                         info <- base::paste(info, collapse = "; ")
[01:29:27.294]                         if (!has_future) {
[01:29:27.294]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.294]                             info)
[01:29:27.294]                         }
[01:29:27.294]                         else {
[01:29:27.294]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.294]                             info, version)
[01:29:27.294]                         }
[01:29:27.294]                         base::stop(msg)
[01:29:27.294]                       }
[01:29:27.294]                     })
[01:29:27.294]                   }
[01:29:27.294]                   options(future.plan = NULL)
[01:29:27.294]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.294]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.294]                 }
[01:29:27.294]                 ...future.workdir <- getwd()
[01:29:27.294]             }
[01:29:27.294]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.294]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.294]         }
[01:29:27.294]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.294]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.294]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.294]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.294]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.294]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.294]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.294]             base::names(...future.oldOptions))
[01:29:27.294]     }
[01:29:27.294]     if (FALSE) {
[01:29:27.294]     }
[01:29:27.294]     else {
[01:29:27.294]         if (TRUE) {
[01:29:27.294]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.294]                 open = "w")
[01:29:27.294]         }
[01:29:27.294]         else {
[01:29:27.294]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.294]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.294]         }
[01:29:27.294]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.294]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.294]             base::sink(type = "output", split = FALSE)
[01:29:27.294]             base::close(...future.stdout)
[01:29:27.294]         }, add = TRUE)
[01:29:27.294]     }
[01:29:27.294]     ...future.frame <- base::sys.nframe()
[01:29:27.294]     ...future.conditions <- base::list()
[01:29:27.294]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.294]     if (FALSE) {
[01:29:27.294]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.294]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.294]     }
[01:29:27.294]     ...future.result <- base::tryCatch({
[01:29:27.294]         base::withCallingHandlers({
[01:29:27.294]             ...future.value <- base::withVisible(base::local({
[01:29:27.294]                 sample(x, size = 1L)
[01:29:27.294]             }))
[01:29:27.294]             future::FutureResult(value = ...future.value$value, 
[01:29:27.294]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.294]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.294]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.294]                     ...future.globalenv.names))
[01:29:27.294]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.294]         }, condition = base::local({
[01:29:27.294]             c <- base::c
[01:29:27.294]             inherits <- base::inherits
[01:29:27.294]             invokeRestart <- base::invokeRestart
[01:29:27.294]             length <- base::length
[01:29:27.294]             list <- base::list
[01:29:27.294]             seq.int <- base::seq.int
[01:29:27.294]             signalCondition <- base::signalCondition
[01:29:27.294]             sys.calls <- base::sys.calls
[01:29:27.294]             `[[` <- base::`[[`
[01:29:27.294]             `+` <- base::`+`
[01:29:27.294]             `<<-` <- base::`<<-`
[01:29:27.294]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.294]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.294]                   3L)]
[01:29:27.294]             }
[01:29:27.294]             function(cond) {
[01:29:27.294]                 is_error <- inherits(cond, "error")
[01:29:27.294]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.294]                   NULL)
[01:29:27.294]                 if (is_error) {
[01:29:27.294]                   sessionInformation <- function() {
[01:29:27.294]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.294]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.294]                       search = base::search(), system = base::Sys.info())
[01:29:27.294]                   }
[01:29:27.294]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.294]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.294]                     cond$call), session = sessionInformation(), 
[01:29:27.294]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.294]                   signalCondition(cond)
[01:29:27.294]                 }
[01:29:27.294]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.294]                 "immediateCondition"))) {
[01:29:27.294]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.294]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.294]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.294]                   if (TRUE && !signal) {
[01:29:27.294]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.294]                     {
[01:29:27.294]                       inherits <- base::inherits
[01:29:27.294]                       invokeRestart <- base::invokeRestart
[01:29:27.294]                       is.null <- base::is.null
[01:29:27.294]                       muffled <- FALSE
[01:29:27.294]                       if (inherits(cond, "message")) {
[01:29:27.294]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.294]                         if (muffled) 
[01:29:27.294]                           invokeRestart("muffleMessage")
[01:29:27.294]                       }
[01:29:27.294]                       else if (inherits(cond, "warning")) {
[01:29:27.294]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.294]                         if (muffled) 
[01:29:27.294]                           invokeRestart("muffleWarning")
[01:29:27.294]                       }
[01:29:27.294]                       else if (inherits(cond, "condition")) {
[01:29:27.294]                         if (!is.null(pattern)) {
[01:29:27.294]                           computeRestarts <- base::computeRestarts
[01:29:27.294]                           grepl <- base::grepl
[01:29:27.294]                           restarts <- computeRestarts(cond)
[01:29:27.294]                           for (restart in restarts) {
[01:29:27.294]                             name <- restart$name
[01:29:27.294]                             if (is.null(name)) 
[01:29:27.294]                               next
[01:29:27.294]                             if (!grepl(pattern, name)) 
[01:29:27.294]                               next
[01:29:27.294]                             invokeRestart(restart)
[01:29:27.294]                             muffled <- TRUE
[01:29:27.294]                             break
[01:29:27.294]                           }
[01:29:27.294]                         }
[01:29:27.294]                       }
[01:29:27.294]                       invisible(muffled)
[01:29:27.294]                     }
[01:29:27.294]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.294]                   }
[01:29:27.294]                 }
[01:29:27.294]                 else {
[01:29:27.294]                   if (TRUE) {
[01:29:27.294]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.294]                     {
[01:29:27.294]                       inherits <- base::inherits
[01:29:27.294]                       invokeRestart <- base::invokeRestart
[01:29:27.294]                       is.null <- base::is.null
[01:29:27.294]                       muffled <- FALSE
[01:29:27.294]                       if (inherits(cond, "message")) {
[01:29:27.294]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.294]                         if (muffled) 
[01:29:27.294]                           invokeRestart("muffleMessage")
[01:29:27.294]                       }
[01:29:27.294]                       else if (inherits(cond, "warning")) {
[01:29:27.294]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.294]                         if (muffled) 
[01:29:27.294]                           invokeRestart("muffleWarning")
[01:29:27.294]                       }
[01:29:27.294]                       else if (inherits(cond, "condition")) {
[01:29:27.294]                         if (!is.null(pattern)) {
[01:29:27.294]                           computeRestarts <- base::computeRestarts
[01:29:27.294]                           grepl <- base::grepl
[01:29:27.294]                           restarts <- computeRestarts(cond)
[01:29:27.294]                           for (restart in restarts) {
[01:29:27.294]                             name <- restart$name
[01:29:27.294]                             if (is.null(name)) 
[01:29:27.294]                               next
[01:29:27.294]                             if (!grepl(pattern, name)) 
[01:29:27.294]                               next
[01:29:27.294]                             invokeRestart(restart)
[01:29:27.294]                             muffled <- TRUE
[01:29:27.294]                             break
[01:29:27.294]                           }
[01:29:27.294]                         }
[01:29:27.294]                       }
[01:29:27.294]                       invisible(muffled)
[01:29:27.294]                     }
[01:29:27.294]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.294]                   }
[01:29:27.294]                 }
[01:29:27.294]             }
[01:29:27.294]         }))
[01:29:27.294]     }, error = function(ex) {
[01:29:27.294]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.294]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.294]                 ...future.rng), started = ...future.startTime, 
[01:29:27.294]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.294]             version = "1.8"), class = "FutureResult")
[01:29:27.294]     }, finally = {
[01:29:27.294]         if (!identical(...future.workdir, getwd())) 
[01:29:27.294]             setwd(...future.workdir)
[01:29:27.294]         {
[01:29:27.294]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.294]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.294]             }
[01:29:27.294]             base::options(...future.oldOptions)
[01:29:27.294]             if (.Platform$OS.type == "windows") {
[01:29:27.294]                 old_names <- names(...future.oldEnvVars)
[01:29:27.294]                 envs <- base::Sys.getenv()
[01:29:27.294]                 names <- names(envs)
[01:29:27.294]                 common <- intersect(names, old_names)
[01:29:27.294]                 added <- setdiff(names, old_names)
[01:29:27.294]                 removed <- setdiff(old_names, names)
[01:29:27.294]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.294]                   envs[common]]
[01:29:27.294]                 NAMES <- toupper(changed)
[01:29:27.294]                 args <- list()
[01:29:27.294]                 for (kk in seq_along(NAMES)) {
[01:29:27.294]                   name <- changed[[kk]]
[01:29:27.294]                   NAME <- NAMES[[kk]]
[01:29:27.294]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.294]                     next
[01:29:27.294]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.294]                 }
[01:29:27.294]                 NAMES <- toupper(added)
[01:29:27.294]                 for (kk in seq_along(NAMES)) {
[01:29:27.294]                   name <- added[[kk]]
[01:29:27.294]                   NAME <- NAMES[[kk]]
[01:29:27.294]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.294]                     next
[01:29:27.294]                   args[[name]] <- ""
[01:29:27.294]                 }
[01:29:27.294]                 NAMES <- toupper(removed)
[01:29:27.294]                 for (kk in seq_along(NAMES)) {
[01:29:27.294]                   name <- removed[[kk]]
[01:29:27.294]                   NAME <- NAMES[[kk]]
[01:29:27.294]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.294]                     next
[01:29:27.294]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.294]                 }
[01:29:27.294]                 if (length(args) > 0) 
[01:29:27.294]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.294]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.294]             }
[01:29:27.294]             else {
[01:29:27.294]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.294]             }
[01:29:27.294]             {
[01:29:27.294]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.294]                   0L) {
[01:29:27.294]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.294]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.294]                   base::options(opts)
[01:29:27.294]                 }
[01:29:27.294]                 {
[01:29:27.294]                   {
[01:29:27.294]                     base::assign(".Random.seed", c(10407L, 1320995057L, 
[01:29:27.294]                     -375345455L, 69301104L, 234633084L, 615948819L, 
[01:29:27.294]                     -1697938701L), envir = base::globalenv(), 
[01:29:27.294]                       inherits = FALSE)
[01:29:27.294]                     NULL
[01:29:27.294]                   }
[01:29:27.294]                   options(future.plan = NULL)
[01:29:27.294]                   if (is.na(NA_character_)) 
[01:29:27.294]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.294]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.294]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.294]                   {
[01:29:27.294]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.294]                     if (!future$lazy) 
[01:29:27.294]                       future <- run(future)
[01:29:27.294]                     invisible(future)
[01:29:27.294]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.294]                 }
[01:29:27.294]             }
[01:29:27.294]         }
[01:29:27.294]     })
[01:29:27.294]     if (TRUE) {
[01:29:27.294]         base::sink(type = "output", split = FALSE)
[01:29:27.294]         if (TRUE) {
[01:29:27.294]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.294]         }
[01:29:27.294]         else {
[01:29:27.294]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.294]         }
[01:29:27.294]         base::close(...future.stdout)
[01:29:27.294]         ...future.stdout <- NULL
[01:29:27.294]     }
[01:29:27.294]     ...future.result$conditions <- ...future.conditions
[01:29:27.294]     ...future.result$finished <- base::Sys.time()
[01:29:27.294]     ...future.result
[01:29:27.294] }
[01:29:27.298] assign_globals() ...
[01:29:27.298] List of 1
[01:29:27.298]  $ x: int [1:4] 0 1 2 3
[01:29:27.298]  - attr(*, "where")=List of 1
[01:29:27.298]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.298]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.298]  - attr(*, "resolved")= logi FALSE
[01:29:27.298]  - attr(*, "total_size")= num 64
[01:29:27.298]  - attr(*, "already-done")= logi TRUE
[01:29:27.302] - copied 'x' to environment
[01:29:27.302] assign_globals() ... done
[01:29:27.303] plan(): Setting new future strategy stack:
[01:29:27.303] List of future strategies:
[01:29:27.303] 1. sequential:
[01:29:27.303]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.303]    - tweaked: FALSE
[01:29:27.303]    - call: NULL
[01:29:27.303] plan(): nbrOfWorkers() = 1
[01:29:27.305] plan(): Setting new future strategy stack:
[01:29:27.305] List of future strategies:
[01:29:27.305] 1. sequential:
[01:29:27.305]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.305]    - tweaked: FALSE
[01:29:27.305]    - call: plan(strategy)
[01:29:27.306] plan(): nbrOfWorkers() = 1
[01:29:27.306] SequentialFuture started (and completed)
[01:29:27.306] - Launch lazy future ... done
[01:29:27.306] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_1-682326'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96cbb6538
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.308] getGlobalsAndPackages() ...
[01:29:27.308] Searching for globals...
[01:29:27.309] - globals found: [3] '{', 'sample', 'x'
[01:29:27.309] Searching for globals ... DONE
[01:29:27.310] Resolving globals: FALSE
[01:29:27.310] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.311] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.311] - globals: [1] 'x'
[01:29:27.311] 
[01:29:27.311] getGlobalsAndPackages() ... DONE
[01:29:27.312] run() for 'Future' ...
[01:29:27.312] - state: 'created'
[01:29:27.312] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.312] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.313] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.313]   - Field: 'label'
[01:29:27.313]   - Field: 'local'
[01:29:27.313]   - Field: 'owner'
[01:29:27.313]   - Field: 'envir'
[01:29:27.314]   - Field: 'packages'
[01:29:27.314]   - Field: 'gc'
[01:29:27.314]   - Field: 'conditions'
[01:29:27.314]   - Field: 'expr'
[01:29:27.314]   - Field: 'uuid'
[01:29:27.315]   - Field: 'seed'
[01:29:27.315]   - Field: 'version'
[01:29:27.315]   - Field: 'result'
[01:29:27.315]   - Field: 'asynchronous'
[01:29:27.316]   - Field: 'calls'
[01:29:27.316]   - Field: 'globals'
[01:29:27.316]   - Field: 'stdout'
[01:29:27.316]   - Field: 'earlySignal'
[01:29:27.316]   - Field: 'lazy'
[01:29:27.316]   - Field: 'state'
[01:29:27.317] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.317] - Launch lazy future ...
[01:29:27.317] Packages needed by the future expression (n = 0): <none>
[01:29:27.317] Packages needed by future strategies (n = 0): <none>
[01:29:27.318] {
[01:29:27.318]     {
[01:29:27.318]         {
[01:29:27.318]             ...future.startTime <- base::Sys.time()
[01:29:27.318]             {
[01:29:27.318]                 {
[01:29:27.318]                   {
[01:29:27.318]                     base::local({
[01:29:27.318]                       has_future <- base::requireNamespace("future", 
[01:29:27.318]                         quietly = TRUE)
[01:29:27.318]                       if (has_future) {
[01:29:27.318]                         ns <- base::getNamespace("future")
[01:29:27.318]                         version <- ns[[".package"]][["version"]]
[01:29:27.318]                         if (is.null(version)) 
[01:29:27.318]                           version <- utils::packageVersion("future")
[01:29:27.318]                       }
[01:29:27.318]                       else {
[01:29:27.318]                         version <- NULL
[01:29:27.318]                       }
[01:29:27.318]                       if (!has_future || version < "1.8.0") {
[01:29:27.318]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.318]                           "", base::R.version$version.string), 
[01:29:27.318]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.318]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.318]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.318]                             "release", "version")], collapse = " "), 
[01:29:27.318]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.318]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.318]                           info)
[01:29:27.318]                         info <- base::paste(info, collapse = "; ")
[01:29:27.318]                         if (!has_future) {
[01:29:27.318]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.318]                             info)
[01:29:27.318]                         }
[01:29:27.318]                         else {
[01:29:27.318]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.318]                             info, version)
[01:29:27.318]                         }
[01:29:27.318]                         base::stop(msg)
[01:29:27.318]                       }
[01:29:27.318]                     })
[01:29:27.318]                   }
[01:29:27.318]                   options(future.plan = NULL)
[01:29:27.318]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.318]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.318]                 }
[01:29:27.318]                 ...future.workdir <- getwd()
[01:29:27.318]             }
[01:29:27.318]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.318]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.318]         }
[01:29:27.318]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.318]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.318]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.318]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.318]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.318]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.318]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.318]             base::names(...future.oldOptions))
[01:29:27.318]     }
[01:29:27.318]     if (FALSE) {
[01:29:27.318]     }
[01:29:27.318]     else {
[01:29:27.318]         if (TRUE) {
[01:29:27.318]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.318]                 open = "w")
[01:29:27.318]         }
[01:29:27.318]         else {
[01:29:27.318]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.318]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.318]         }
[01:29:27.318]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.318]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.318]             base::sink(type = "output", split = FALSE)
[01:29:27.318]             base::close(...future.stdout)
[01:29:27.318]         }, add = TRUE)
[01:29:27.318]     }
[01:29:27.318]     ...future.frame <- base::sys.nframe()
[01:29:27.318]     ...future.conditions <- base::list()
[01:29:27.318]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.318]     if (FALSE) {
[01:29:27.318]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.318]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.318]     }
[01:29:27.318]     ...future.result <- base::tryCatch({
[01:29:27.318]         base::withCallingHandlers({
[01:29:27.318]             ...future.value <- base::withVisible(base::local({
[01:29:27.318]                 sample(x, size = 1L)
[01:29:27.318]             }))
[01:29:27.318]             future::FutureResult(value = ...future.value$value, 
[01:29:27.318]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.318]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.318]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.318]                     ...future.globalenv.names))
[01:29:27.318]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.318]         }, condition = base::local({
[01:29:27.318]             c <- base::c
[01:29:27.318]             inherits <- base::inherits
[01:29:27.318]             invokeRestart <- base::invokeRestart
[01:29:27.318]             length <- base::length
[01:29:27.318]             list <- base::list
[01:29:27.318]             seq.int <- base::seq.int
[01:29:27.318]             signalCondition <- base::signalCondition
[01:29:27.318]             sys.calls <- base::sys.calls
[01:29:27.318]             `[[` <- base::`[[`
[01:29:27.318]             `+` <- base::`+`
[01:29:27.318]             `<<-` <- base::`<<-`
[01:29:27.318]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.318]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.318]                   3L)]
[01:29:27.318]             }
[01:29:27.318]             function(cond) {
[01:29:27.318]                 is_error <- inherits(cond, "error")
[01:29:27.318]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.318]                   NULL)
[01:29:27.318]                 if (is_error) {
[01:29:27.318]                   sessionInformation <- function() {
[01:29:27.318]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.318]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.318]                       search = base::search(), system = base::Sys.info())
[01:29:27.318]                   }
[01:29:27.318]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.318]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.318]                     cond$call), session = sessionInformation(), 
[01:29:27.318]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.318]                   signalCondition(cond)
[01:29:27.318]                 }
[01:29:27.318]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.318]                 "immediateCondition"))) {
[01:29:27.318]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.318]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.318]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.318]                   if (TRUE && !signal) {
[01:29:27.318]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.318]                     {
[01:29:27.318]                       inherits <- base::inherits
[01:29:27.318]                       invokeRestart <- base::invokeRestart
[01:29:27.318]                       is.null <- base::is.null
[01:29:27.318]                       muffled <- FALSE
[01:29:27.318]                       if (inherits(cond, "message")) {
[01:29:27.318]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.318]                         if (muffled) 
[01:29:27.318]                           invokeRestart("muffleMessage")
[01:29:27.318]                       }
[01:29:27.318]                       else if (inherits(cond, "warning")) {
[01:29:27.318]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.318]                         if (muffled) 
[01:29:27.318]                           invokeRestart("muffleWarning")
[01:29:27.318]                       }
[01:29:27.318]                       else if (inherits(cond, "condition")) {
[01:29:27.318]                         if (!is.null(pattern)) {
[01:29:27.318]                           computeRestarts <- base::computeRestarts
[01:29:27.318]                           grepl <- base::grepl
[01:29:27.318]                           restarts <- computeRestarts(cond)
[01:29:27.318]                           for (restart in restarts) {
[01:29:27.318]                             name <- restart$name
[01:29:27.318]                             if (is.null(name)) 
[01:29:27.318]                               next
[01:29:27.318]                             if (!grepl(pattern, name)) 
[01:29:27.318]                               next
[01:29:27.318]                             invokeRestart(restart)
[01:29:27.318]                             muffled <- TRUE
[01:29:27.318]                             break
[01:29:27.318]                           }
[01:29:27.318]                         }
[01:29:27.318]                       }
[01:29:27.318]                       invisible(muffled)
[01:29:27.318]                     }
[01:29:27.318]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.318]                   }
[01:29:27.318]                 }
[01:29:27.318]                 else {
[01:29:27.318]                   if (TRUE) {
[01:29:27.318]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.318]                     {
[01:29:27.318]                       inherits <- base::inherits
[01:29:27.318]                       invokeRestart <- base::invokeRestart
[01:29:27.318]                       is.null <- base::is.null
[01:29:27.318]                       muffled <- FALSE
[01:29:27.318]                       if (inherits(cond, "message")) {
[01:29:27.318]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.318]                         if (muffled) 
[01:29:27.318]                           invokeRestart("muffleMessage")
[01:29:27.318]                       }
[01:29:27.318]                       else if (inherits(cond, "warning")) {
[01:29:27.318]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.318]                         if (muffled) 
[01:29:27.318]                           invokeRestart("muffleWarning")
[01:29:27.318]                       }
[01:29:27.318]                       else if (inherits(cond, "condition")) {
[01:29:27.318]                         if (!is.null(pattern)) {
[01:29:27.318]                           computeRestarts <- base::computeRestarts
[01:29:27.318]                           grepl <- base::grepl
[01:29:27.318]                           restarts <- computeRestarts(cond)
[01:29:27.318]                           for (restart in restarts) {
[01:29:27.318]                             name <- restart$name
[01:29:27.318]                             if (is.null(name)) 
[01:29:27.318]                               next
[01:29:27.318]                             if (!grepl(pattern, name)) 
[01:29:27.318]                               next
[01:29:27.318]                             invokeRestart(restart)
[01:29:27.318]                             muffled <- TRUE
[01:29:27.318]                             break
[01:29:27.318]                           }
[01:29:27.318]                         }
[01:29:27.318]                       }
[01:29:27.318]                       invisible(muffled)
[01:29:27.318]                     }
[01:29:27.318]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.318]                   }
[01:29:27.318]                 }
[01:29:27.318]             }
[01:29:27.318]         }))
[01:29:27.318]     }, error = function(ex) {
[01:29:27.318]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.318]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.318]                 ...future.rng), started = ...future.startTime, 
[01:29:27.318]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.318]             version = "1.8"), class = "FutureResult")
[01:29:27.318]     }, finally = {
[01:29:27.318]         if (!identical(...future.workdir, getwd())) 
[01:29:27.318]             setwd(...future.workdir)
[01:29:27.318]         {
[01:29:27.318]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.318]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.318]             }
[01:29:27.318]             base::options(...future.oldOptions)
[01:29:27.318]             if (.Platform$OS.type == "windows") {
[01:29:27.318]                 old_names <- names(...future.oldEnvVars)
[01:29:27.318]                 envs <- base::Sys.getenv()
[01:29:27.318]                 names <- names(envs)
[01:29:27.318]                 common <- intersect(names, old_names)
[01:29:27.318]                 added <- setdiff(names, old_names)
[01:29:27.318]                 removed <- setdiff(old_names, names)
[01:29:27.318]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.318]                   envs[common]]
[01:29:27.318]                 NAMES <- toupper(changed)
[01:29:27.318]                 args <- list()
[01:29:27.318]                 for (kk in seq_along(NAMES)) {
[01:29:27.318]                   name <- changed[[kk]]
[01:29:27.318]                   NAME <- NAMES[[kk]]
[01:29:27.318]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.318]                     next
[01:29:27.318]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.318]                 }
[01:29:27.318]                 NAMES <- toupper(added)
[01:29:27.318]                 for (kk in seq_along(NAMES)) {
[01:29:27.318]                   name <- added[[kk]]
[01:29:27.318]                   NAME <- NAMES[[kk]]
[01:29:27.318]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.318]                     next
[01:29:27.318]                   args[[name]] <- ""
[01:29:27.318]                 }
[01:29:27.318]                 NAMES <- toupper(removed)
[01:29:27.318]                 for (kk in seq_along(NAMES)) {
[01:29:27.318]                   name <- removed[[kk]]
[01:29:27.318]                   NAME <- NAMES[[kk]]
[01:29:27.318]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.318]                     next
[01:29:27.318]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.318]                 }
[01:29:27.318]                 if (length(args) > 0) 
[01:29:27.318]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.318]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.318]             }
[01:29:27.318]             else {
[01:29:27.318]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.318]             }
[01:29:27.318]             {
[01:29:27.318]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.318]                   0L) {
[01:29:27.318]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.318]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.318]                   base::options(opts)
[01:29:27.318]                 }
[01:29:27.318]                 {
[01:29:27.318]                   {
[01:29:27.318]                     base::assign(".Random.seed", c(10407L, 1711451082L, 
[01:29:27.318]                     -154467960L, 1752249982L, -183923976L, 802413990L, 
[01:29:27.318]                     -1367522548L), envir = base::globalenv(), 
[01:29:27.318]                       inherits = FALSE)
[01:29:27.318]                     NULL
[01:29:27.318]                   }
[01:29:27.318]                   options(future.plan = NULL)
[01:29:27.318]                   if (is.na(NA_character_)) 
[01:29:27.318]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.318]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.318]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.318]                   {
[01:29:27.318]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.318]                     if (!future$lazy) 
[01:29:27.318]                       future <- run(future)
[01:29:27.318]                     invisible(future)
[01:29:27.318]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.318]                 }
[01:29:27.318]             }
[01:29:27.318]         }
[01:29:27.318]     })
[01:29:27.318]     if (TRUE) {
[01:29:27.318]         base::sink(type = "output", split = FALSE)
[01:29:27.318]         if (TRUE) {
[01:29:27.318]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.318]         }
[01:29:27.318]         else {
[01:29:27.318]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.318]         }
[01:29:27.318]         base::close(...future.stdout)
[01:29:27.318]         ...future.stdout <- NULL
[01:29:27.318]     }
[01:29:27.318]     ...future.result$conditions <- ...future.conditions
[01:29:27.318]     ...future.result$finished <- base::Sys.time()
[01:29:27.318]     ...future.result
[01:29:27.318] }
[01:29:27.322] assign_globals() ...
[01:29:27.322] List of 1
[01:29:27.322]  $ x: int [1:4] 0 1 2 3
[01:29:27.322]  - attr(*, "where")=List of 1
[01:29:27.322]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.322]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.322]  - attr(*, "resolved")= logi FALSE
[01:29:27.322]  - attr(*, "total_size")= num 64
[01:29:27.322]  - attr(*, "already-done")= logi TRUE
[01:29:27.327] - copied 'x' to environment
[01:29:27.327] assign_globals() ... done
[01:29:27.327] plan(): Setting new future strategy stack:
[01:29:27.328] List of future strategies:
[01:29:27.328] 1. sequential:
[01:29:27.328]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.328]    - tweaked: FALSE
[01:29:27.328]    - call: NULL
[01:29:27.328] plan(): nbrOfWorkers() = 1
[01:29:27.330] plan(): Setting new future strategy stack:
[01:29:27.330] List of future strategies:
[01:29:27.330] 1. sequential:
[01:29:27.330]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.330]    - tweaked: FALSE
[01:29:27.330]    - call: plan(strategy)
[01:29:27.330] plan(): nbrOfWorkers() = 1
[01:29:27.331] SequentialFuture started (and completed)
[01:29:27.331] - Launch lazy future ... done
[01:29:27.331] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_2-506356'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96cbb6538
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.332] getGlobalsAndPackages() ...
[01:29:27.332] Searching for globals...
[01:29:27.334] - globals found: [3] '{', 'sample', 'x'
[01:29:27.334] Searching for globals ... DONE
[01:29:27.334] Resolving globals: FALSE
[01:29:27.334] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.335] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.335] - globals: [1] 'x'
[01:29:27.335] 
[01:29:27.335] getGlobalsAndPackages() ... DONE
[01:29:27.336] run() for 'Future' ...
[01:29:27.336] - state: 'created'
[01:29:27.336] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.337] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.337] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.337]   - Field: 'label'
[01:29:27.337]   - Field: 'local'
[01:29:27.337]   - Field: 'owner'
[01:29:27.338]   - Field: 'envir'
[01:29:27.338]   - Field: 'packages'
[01:29:27.338]   - Field: 'gc'
[01:29:27.338]   - Field: 'conditions'
[01:29:27.338]   - Field: 'expr'
[01:29:27.338]   - Field: 'uuid'
[01:29:27.339]   - Field: 'seed'
[01:29:27.339]   - Field: 'version'
[01:29:27.339]   - Field: 'result'
[01:29:27.339]   - Field: 'asynchronous'
[01:29:27.339]   - Field: 'calls'
[01:29:27.340]   - Field: 'globals'
[01:29:27.340]   - Field: 'stdout'
[01:29:27.340]   - Field: 'earlySignal'
[01:29:27.340]   - Field: 'lazy'
[01:29:27.340]   - Field: 'state'
[01:29:27.340] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.341] - Launch lazy future ...
[01:29:27.341] Packages needed by the future expression (n = 0): <none>
[01:29:27.341] Packages needed by future strategies (n = 0): <none>
[01:29:27.342] {
[01:29:27.342]     {
[01:29:27.342]         {
[01:29:27.342]             ...future.startTime <- base::Sys.time()
[01:29:27.342]             {
[01:29:27.342]                 {
[01:29:27.342]                   {
[01:29:27.342]                     base::local({
[01:29:27.342]                       has_future <- base::requireNamespace("future", 
[01:29:27.342]                         quietly = TRUE)
[01:29:27.342]                       if (has_future) {
[01:29:27.342]                         ns <- base::getNamespace("future")
[01:29:27.342]                         version <- ns[[".package"]][["version"]]
[01:29:27.342]                         if (is.null(version)) 
[01:29:27.342]                           version <- utils::packageVersion("future")
[01:29:27.342]                       }
[01:29:27.342]                       else {
[01:29:27.342]                         version <- NULL
[01:29:27.342]                       }
[01:29:27.342]                       if (!has_future || version < "1.8.0") {
[01:29:27.342]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.342]                           "", base::R.version$version.string), 
[01:29:27.342]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.342]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.342]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.342]                             "release", "version")], collapse = " "), 
[01:29:27.342]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.342]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.342]                           info)
[01:29:27.342]                         info <- base::paste(info, collapse = "; ")
[01:29:27.342]                         if (!has_future) {
[01:29:27.342]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.342]                             info)
[01:29:27.342]                         }
[01:29:27.342]                         else {
[01:29:27.342]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.342]                             info, version)
[01:29:27.342]                         }
[01:29:27.342]                         base::stop(msg)
[01:29:27.342]                       }
[01:29:27.342]                     })
[01:29:27.342]                   }
[01:29:27.342]                   options(future.plan = NULL)
[01:29:27.342]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.342]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.342]                 }
[01:29:27.342]                 ...future.workdir <- getwd()
[01:29:27.342]             }
[01:29:27.342]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.342]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.342]         }
[01:29:27.342]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.342]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.342]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.342]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.342]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.342]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.342]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.342]             base::names(...future.oldOptions))
[01:29:27.342]     }
[01:29:27.342]     if (FALSE) {
[01:29:27.342]     }
[01:29:27.342]     else {
[01:29:27.342]         if (TRUE) {
[01:29:27.342]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.342]                 open = "w")
[01:29:27.342]         }
[01:29:27.342]         else {
[01:29:27.342]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.342]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.342]         }
[01:29:27.342]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.342]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.342]             base::sink(type = "output", split = FALSE)
[01:29:27.342]             base::close(...future.stdout)
[01:29:27.342]         }, add = TRUE)
[01:29:27.342]     }
[01:29:27.342]     ...future.frame <- base::sys.nframe()
[01:29:27.342]     ...future.conditions <- base::list()
[01:29:27.342]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.342]     if (FALSE) {
[01:29:27.342]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.342]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.342]     }
[01:29:27.342]     ...future.result <- base::tryCatch({
[01:29:27.342]         base::withCallingHandlers({
[01:29:27.342]             ...future.value <- base::withVisible(base::local({
[01:29:27.342]                 sample(x, size = 1L)
[01:29:27.342]             }))
[01:29:27.342]             future::FutureResult(value = ...future.value$value, 
[01:29:27.342]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.342]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.342]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.342]                     ...future.globalenv.names))
[01:29:27.342]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.342]         }, condition = base::local({
[01:29:27.342]             c <- base::c
[01:29:27.342]             inherits <- base::inherits
[01:29:27.342]             invokeRestart <- base::invokeRestart
[01:29:27.342]             length <- base::length
[01:29:27.342]             list <- base::list
[01:29:27.342]             seq.int <- base::seq.int
[01:29:27.342]             signalCondition <- base::signalCondition
[01:29:27.342]             sys.calls <- base::sys.calls
[01:29:27.342]             `[[` <- base::`[[`
[01:29:27.342]             `+` <- base::`+`
[01:29:27.342]             `<<-` <- base::`<<-`
[01:29:27.342]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.342]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.342]                   3L)]
[01:29:27.342]             }
[01:29:27.342]             function(cond) {
[01:29:27.342]                 is_error <- inherits(cond, "error")
[01:29:27.342]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.342]                   NULL)
[01:29:27.342]                 if (is_error) {
[01:29:27.342]                   sessionInformation <- function() {
[01:29:27.342]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.342]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.342]                       search = base::search(), system = base::Sys.info())
[01:29:27.342]                   }
[01:29:27.342]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.342]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.342]                     cond$call), session = sessionInformation(), 
[01:29:27.342]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.342]                   signalCondition(cond)
[01:29:27.342]                 }
[01:29:27.342]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.342]                 "immediateCondition"))) {
[01:29:27.342]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.342]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.342]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.342]                   if (TRUE && !signal) {
[01:29:27.342]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.342]                     {
[01:29:27.342]                       inherits <- base::inherits
[01:29:27.342]                       invokeRestart <- base::invokeRestart
[01:29:27.342]                       is.null <- base::is.null
[01:29:27.342]                       muffled <- FALSE
[01:29:27.342]                       if (inherits(cond, "message")) {
[01:29:27.342]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.342]                         if (muffled) 
[01:29:27.342]                           invokeRestart("muffleMessage")
[01:29:27.342]                       }
[01:29:27.342]                       else if (inherits(cond, "warning")) {
[01:29:27.342]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.342]                         if (muffled) 
[01:29:27.342]                           invokeRestart("muffleWarning")
[01:29:27.342]                       }
[01:29:27.342]                       else if (inherits(cond, "condition")) {
[01:29:27.342]                         if (!is.null(pattern)) {
[01:29:27.342]                           computeRestarts <- base::computeRestarts
[01:29:27.342]                           grepl <- base::grepl
[01:29:27.342]                           restarts <- computeRestarts(cond)
[01:29:27.342]                           for (restart in restarts) {
[01:29:27.342]                             name <- restart$name
[01:29:27.342]                             if (is.null(name)) 
[01:29:27.342]                               next
[01:29:27.342]                             if (!grepl(pattern, name)) 
[01:29:27.342]                               next
[01:29:27.342]                             invokeRestart(restart)
[01:29:27.342]                             muffled <- TRUE
[01:29:27.342]                             break
[01:29:27.342]                           }
[01:29:27.342]                         }
[01:29:27.342]                       }
[01:29:27.342]                       invisible(muffled)
[01:29:27.342]                     }
[01:29:27.342]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.342]                   }
[01:29:27.342]                 }
[01:29:27.342]                 else {
[01:29:27.342]                   if (TRUE) {
[01:29:27.342]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.342]                     {
[01:29:27.342]                       inherits <- base::inherits
[01:29:27.342]                       invokeRestart <- base::invokeRestart
[01:29:27.342]                       is.null <- base::is.null
[01:29:27.342]                       muffled <- FALSE
[01:29:27.342]                       if (inherits(cond, "message")) {
[01:29:27.342]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.342]                         if (muffled) 
[01:29:27.342]                           invokeRestart("muffleMessage")
[01:29:27.342]                       }
[01:29:27.342]                       else if (inherits(cond, "warning")) {
[01:29:27.342]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.342]                         if (muffled) 
[01:29:27.342]                           invokeRestart("muffleWarning")
[01:29:27.342]                       }
[01:29:27.342]                       else if (inherits(cond, "condition")) {
[01:29:27.342]                         if (!is.null(pattern)) {
[01:29:27.342]                           computeRestarts <- base::computeRestarts
[01:29:27.342]                           grepl <- base::grepl
[01:29:27.342]                           restarts <- computeRestarts(cond)
[01:29:27.342]                           for (restart in restarts) {
[01:29:27.342]                             name <- restart$name
[01:29:27.342]                             if (is.null(name)) 
[01:29:27.342]                               next
[01:29:27.342]                             if (!grepl(pattern, name)) 
[01:29:27.342]                               next
[01:29:27.342]                             invokeRestart(restart)
[01:29:27.342]                             muffled <- TRUE
[01:29:27.342]                             break
[01:29:27.342]                           }
[01:29:27.342]                         }
[01:29:27.342]                       }
[01:29:27.342]                       invisible(muffled)
[01:29:27.342]                     }
[01:29:27.342]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.342]                   }
[01:29:27.342]                 }
[01:29:27.342]             }
[01:29:27.342]         }))
[01:29:27.342]     }, error = function(ex) {
[01:29:27.342]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.342]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.342]                 ...future.rng), started = ...future.startTime, 
[01:29:27.342]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.342]             version = "1.8"), class = "FutureResult")
[01:29:27.342]     }, finally = {
[01:29:27.342]         if (!identical(...future.workdir, getwd())) 
[01:29:27.342]             setwd(...future.workdir)
[01:29:27.342]         {
[01:29:27.342]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.342]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.342]             }
[01:29:27.342]             base::options(...future.oldOptions)
[01:29:27.342]             if (.Platform$OS.type == "windows") {
[01:29:27.342]                 old_names <- names(...future.oldEnvVars)
[01:29:27.342]                 envs <- base::Sys.getenv()
[01:29:27.342]                 names <- names(envs)
[01:29:27.342]                 common <- intersect(names, old_names)
[01:29:27.342]                 added <- setdiff(names, old_names)
[01:29:27.342]                 removed <- setdiff(old_names, names)
[01:29:27.342]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.342]                   envs[common]]
[01:29:27.342]                 NAMES <- toupper(changed)
[01:29:27.342]                 args <- list()
[01:29:27.342]                 for (kk in seq_along(NAMES)) {
[01:29:27.342]                   name <- changed[[kk]]
[01:29:27.342]                   NAME <- NAMES[[kk]]
[01:29:27.342]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.342]                     next
[01:29:27.342]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.342]                 }
[01:29:27.342]                 NAMES <- toupper(added)
[01:29:27.342]                 for (kk in seq_along(NAMES)) {
[01:29:27.342]                   name <- added[[kk]]
[01:29:27.342]                   NAME <- NAMES[[kk]]
[01:29:27.342]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.342]                     next
[01:29:27.342]                   args[[name]] <- ""
[01:29:27.342]                 }
[01:29:27.342]                 NAMES <- toupper(removed)
[01:29:27.342]                 for (kk in seq_along(NAMES)) {
[01:29:27.342]                   name <- removed[[kk]]
[01:29:27.342]                   NAME <- NAMES[[kk]]
[01:29:27.342]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.342]                     next
[01:29:27.342]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.342]                 }
[01:29:27.342]                 if (length(args) > 0) 
[01:29:27.342]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.342]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.342]             }
[01:29:27.342]             else {
[01:29:27.342]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.342]             }
[01:29:27.342]             {
[01:29:27.342]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.342]                   0L) {
[01:29:27.342]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.342]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.342]                   base::options(opts)
[01:29:27.342]                 }
[01:29:27.342]                 {
[01:29:27.342]                   {
[01:29:27.342]                     base::assign(".Random.seed", c(10407L, 1752249982L, 
[01:29:27.342]                     -37979766L, -997816390L, -1367522548L, -1785432074L, 
[01:29:27.342]                     -889426559L), envir = base::globalenv(), 
[01:29:27.342]                       inherits = FALSE)
[01:29:27.342]                     NULL
[01:29:27.342]                   }
[01:29:27.342]                   options(future.plan = NULL)
[01:29:27.342]                   if (is.na(NA_character_)) 
[01:29:27.342]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.342]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.342]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.342]                   {
[01:29:27.342]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.342]                     if (!future$lazy) 
[01:29:27.342]                       future <- run(future)
[01:29:27.342]                     invisible(future)
[01:29:27.342]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.342]                 }
[01:29:27.342]             }
[01:29:27.342]         }
[01:29:27.342]     })
[01:29:27.342]     if (TRUE) {
[01:29:27.342]         base::sink(type = "output", split = FALSE)
[01:29:27.342]         if (TRUE) {
[01:29:27.342]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.342]         }
[01:29:27.342]         else {
[01:29:27.342]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.342]         }
[01:29:27.342]         base::close(...future.stdout)
[01:29:27.342]         ...future.stdout <- NULL
[01:29:27.342]     }
[01:29:27.342]     ...future.result$conditions <- ...future.conditions
[01:29:27.342]     ...future.result$finished <- base::Sys.time()
[01:29:27.342]     ...future.result
[01:29:27.342] }
[01:29:27.346] assign_globals() ...
[01:29:27.346] List of 1
[01:29:27.346]  $ x: int [1:4] 0 1 2 3
[01:29:27.346]  - attr(*, "where")=List of 1
[01:29:27.346]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.346]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.346]  - attr(*, "resolved")= logi FALSE
[01:29:27.346]  - attr(*, "total_size")= num 64
[01:29:27.346]  - attr(*, "already-done")= logi TRUE
[01:29:27.349] - copied 'x' to environment
[01:29:27.349] assign_globals() ... done
[01:29:27.350] plan(): Setting new future strategy stack:
[01:29:27.350] List of future strategies:
[01:29:27.350] 1. sequential:
[01:29:27.350]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.350]    - tweaked: FALSE
[01:29:27.350]    - call: NULL
[01:29:27.351] plan(): nbrOfWorkers() = 1
[01:29:27.352] plan(): Setting new future strategy stack:
[01:29:27.352] List of future strategies:
[01:29:27.352] 1. sequential:
[01:29:27.352]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.352]    - tweaked: FALSE
[01:29:27.352]    - call: plan(strategy)
[01:29:27.353] plan(): nbrOfWorkers() = 1
[01:29:27.353] SequentialFuture started (and completed)
[01:29:27.353] - Launch lazy future ... done
[01:29:27.353] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_3-588171'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96cbb6538
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.355] getGlobalsAndPackages() ...
[01:29:27.355] Searching for globals...
[01:29:27.356] - globals found: [3] '{', 'sample', 'x'
[01:29:27.356] Searching for globals ... DONE
[01:29:27.356] Resolving globals: FALSE
[01:29:27.357] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.357] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.358] - globals: [1] 'x'
[01:29:27.358] 
[01:29:27.358] getGlobalsAndPackages() ... DONE
[01:29:27.358] run() for 'Future' ...
[01:29:27.359] - state: 'created'
[01:29:27.359] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.359] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.359] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.360]   - Field: 'label'
[01:29:27.360]   - Field: 'local'
[01:29:27.360]   - Field: 'owner'
[01:29:27.360]   - Field: 'envir'
[01:29:27.360]   - Field: 'packages'
[01:29:27.361]   - Field: 'gc'
[01:29:27.361]   - Field: 'conditions'
[01:29:27.361]   - Field: 'expr'
[01:29:27.361]   - Field: 'uuid'
[01:29:27.361]   - Field: 'seed'
[01:29:27.362]   - Field: 'version'
[01:29:27.362]   - Field: 'result'
[01:29:27.362]   - Field: 'asynchronous'
[01:29:27.362]   - Field: 'calls'
[01:29:27.362]   - Field: 'globals'
[01:29:27.363]   - Field: 'stdout'
[01:29:27.363]   - Field: 'earlySignal'
[01:29:27.363]   - Field: 'lazy'
[01:29:27.363]   - Field: 'state'
[01:29:27.363] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.364] - Launch lazy future ...
[01:29:27.364] Packages needed by the future expression (n = 0): <none>
[01:29:27.364] Packages needed by future strategies (n = 0): <none>
[01:29:27.366] {
[01:29:27.366]     {
[01:29:27.366]         {
[01:29:27.366]             ...future.startTime <- base::Sys.time()
[01:29:27.366]             {
[01:29:27.366]                 {
[01:29:27.366]                   {
[01:29:27.366]                     base::local({
[01:29:27.366]                       has_future <- base::requireNamespace("future", 
[01:29:27.366]                         quietly = TRUE)
[01:29:27.366]                       if (has_future) {
[01:29:27.366]                         ns <- base::getNamespace("future")
[01:29:27.366]                         version <- ns[[".package"]][["version"]]
[01:29:27.366]                         if (is.null(version)) 
[01:29:27.366]                           version <- utils::packageVersion("future")
[01:29:27.366]                       }
[01:29:27.366]                       else {
[01:29:27.366]                         version <- NULL
[01:29:27.366]                       }
[01:29:27.366]                       if (!has_future || version < "1.8.0") {
[01:29:27.366]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.366]                           "", base::R.version$version.string), 
[01:29:27.366]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.366]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.366]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.366]                             "release", "version")], collapse = " "), 
[01:29:27.366]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.366]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.366]                           info)
[01:29:27.366]                         info <- base::paste(info, collapse = "; ")
[01:29:27.366]                         if (!has_future) {
[01:29:27.366]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.366]                             info)
[01:29:27.366]                         }
[01:29:27.366]                         else {
[01:29:27.366]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.366]                             info, version)
[01:29:27.366]                         }
[01:29:27.366]                         base::stop(msg)
[01:29:27.366]                       }
[01:29:27.366]                     })
[01:29:27.366]                   }
[01:29:27.366]                   options(future.plan = NULL)
[01:29:27.366]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.366]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.366]                 }
[01:29:27.366]                 ...future.workdir <- getwd()
[01:29:27.366]             }
[01:29:27.366]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.366]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.366]         }
[01:29:27.366]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.366]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.366]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.366]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.366]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.366]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.366]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.366]             base::names(...future.oldOptions))
[01:29:27.366]     }
[01:29:27.366]     if (FALSE) {
[01:29:27.366]     }
[01:29:27.366]     else {
[01:29:27.366]         if (TRUE) {
[01:29:27.366]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.366]                 open = "w")
[01:29:27.366]         }
[01:29:27.366]         else {
[01:29:27.366]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.366]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.366]         }
[01:29:27.366]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.366]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.366]             base::sink(type = "output", split = FALSE)
[01:29:27.366]             base::close(...future.stdout)
[01:29:27.366]         }, add = TRUE)
[01:29:27.366]     }
[01:29:27.366]     ...future.frame <- base::sys.nframe()
[01:29:27.366]     ...future.conditions <- base::list()
[01:29:27.366]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.366]     if (FALSE) {
[01:29:27.366]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.366]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.366]     }
[01:29:27.366]     ...future.result <- base::tryCatch({
[01:29:27.366]         base::withCallingHandlers({
[01:29:27.366]             ...future.value <- base::withVisible(base::local({
[01:29:27.366]                 sample(x, size = 1L)
[01:29:27.366]             }))
[01:29:27.366]             future::FutureResult(value = ...future.value$value, 
[01:29:27.366]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.366]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.366]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.366]                     ...future.globalenv.names))
[01:29:27.366]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.366]         }, condition = base::local({
[01:29:27.366]             c <- base::c
[01:29:27.366]             inherits <- base::inherits
[01:29:27.366]             invokeRestart <- base::invokeRestart
[01:29:27.366]             length <- base::length
[01:29:27.366]             list <- base::list
[01:29:27.366]             seq.int <- base::seq.int
[01:29:27.366]             signalCondition <- base::signalCondition
[01:29:27.366]             sys.calls <- base::sys.calls
[01:29:27.366]             `[[` <- base::`[[`
[01:29:27.366]             `+` <- base::`+`
[01:29:27.366]             `<<-` <- base::`<<-`
[01:29:27.366]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.366]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.366]                   3L)]
[01:29:27.366]             }
[01:29:27.366]             function(cond) {
[01:29:27.366]                 is_error <- inherits(cond, "error")
[01:29:27.366]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.366]                   NULL)
[01:29:27.366]                 if (is_error) {
[01:29:27.366]                   sessionInformation <- function() {
[01:29:27.366]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.366]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.366]                       search = base::search(), system = base::Sys.info())
[01:29:27.366]                   }
[01:29:27.366]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.366]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.366]                     cond$call), session = sessionInformation(), 
[01:29:27.366]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.366]                   signalCondition(cond)
[01:29:27.366]                 }
[01:29:27.366]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.366]                 "immediateCondition"))) {
[01:29:27.366]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.366]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.366]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.366]                   if (TRUE && !signal) {
[01:29:27.366]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.366]                     {
[01:29:27.366]                       inherits <- base::inherits
[01:29:27.366]                       invokeRestart <- base::invokeRestart
[01:29:27.366]                       is.null <- base::is.null
[01:29:27.366]                       muffled <- FALSE
[01:29:27.366]                       if (inherits(cond, "message")) {
[01:29:27.366]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.366]                         if (muffled) 
[01:29:27.366]                           invokeRestart("muffleMessage")
[01:29:27.366]                       }
[01:29:27.366]                       else if (inherits(cond, "warning")) {
[01:29:27.366]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.366]                         if (muffled) 
[01:29:27.366]                           invokeRestart("muffleWarning")
[01:29:27.366]                       }
[01:29:27.366]                       else if (inherits(cond, "condition")) {
[01:29:27.366]                         if (!is.null(pattern)) {
[01:29:27.366]                           computeRestarts <- base::computeRestarts
[01:29:27.366]                           grepl <- base::grepl
[01:29:27.366]                           restarts <- computeRestarts(cond)
[01:29:27.366]                           for (restart in restarts) {
[01:29:27.366]                             name <- restart$name
[01:29:27.366]                             if (is.null(name)) 
[01:29:27.366]                               next
[01:29:27.366]                             if (!grepl(pattern, name)) 
[01:29:27.366]                               next
[01:29:27.366]                             invokeRestart(restart)
[01:29:27.366]                             muffled <- TRUE
[01:29:27.366]                             break
[01:29:27.366]                           }
[01:29:27.366]                         }
[01:29:27.366]                       }
[01:29:27.366]                       invisible(muffled)
[01:29:27.366]                     }
[01:29:27.366]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.366]                   }
[01:29:27.366]                 }
[01:29:27.366]                 else {
[01:29:27.366]                   if (TRUE) {
[01:29:27.366]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.366]                     {
[01:29:27.366]                       inherits <- base::inherits
[01:29:27.366]                       invokeRestart <- base::invokeRestart
[01:29:27.366]                       is.null <- base::is.null
[01:29:27.366]                       muffled <- FALSE
[01:29:27.366]                       if (inherits(cond, "message")) {
[01:29:27.366]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.366]                         if (muffled) 
[01:29:27.366]                           invokeRestart("muffleMessage")
[01:29:27.366]                       }
[01:29:27.366]                       else if (inherits(cond, "warning")) {
[01:29:27.366]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.366]                         if (muffled) 
[01:29:27.366]                           invokeRestart("muffleWarning")
[01:29:27.366]                       }
[01:29:27.366]                       else if (inherits(cond, "condition")) {
[01:29:27.366]                         if (!is.null(pattern)) {
[01:29:27.366]                           computeRestarts <- base::computeRestarts
[01:29:27.366]                           grepl <- base::grepl
[01:29:27.366]                           restarts <- computeRestarts(cond)
[01:29:27.366]                           for (restart in restarts) {
[01:29:27.366]                             name <- restart$name
[01:29:27.366]                             if (is.null(name)) 
[01:29:27.366]                               next
[01:29:27.366]                             if (!grepl(pattern, name)) 
[01:29:27.366]                               next
[01:29:27.366]                             invokeRestart(restart)
[01:29:27.366]                             muffled <- TRUE
[01:29:27.366]                             break
[01:29:27.366]                           }
[01:29:27.366]                         }
[01:29:27.366]                       }
[01:29:27.366]                       invisible(muffled)
[01:29:27.366]                     }
[01:29:27.366]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.366]                   }
[01:29:27.366]                 }
[01:29:27.366]             }
[01:29:27.366]         }))
[01:29:27.366]     }, error = function(ex) {
[01:29:27.366]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.366]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.366]                 ...future.rng), started = ...future.startTime, 
[01:29:27.366]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.366]             version = "1.8"), class = "FutureResult")
[01:29:27.366]     }, finally = {
[01:29:27.366]         if (!identical(...future.workdir, getwd())) 
[01:29:27.366]             setwd(...future.workdir)
[01:29:27.366]         {
[01:29:27.366]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.366]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.366]             }
[01:29:27.366]             base::options(...future.oldOptions)
[01:29:27.366]             if (.Platform$OS.type == "windows") {
[01:29:27.366]                 old_names <- names(...future.oldEnvVars)
[01:29:27.366]                 envs <- base::Sys.getenv()
[01:29:27.366]                 names <- names(envs)
[01:29:27.366]                 common <- intersect(names, old_names)
[01:29:27.366]                 added <- setdiff(names, old_names)
[01:29:27.366]                 removed <- setdiff(old_names, names)
[01:29:27.366]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.366]                   envs[common]]
[01:29:27.366]                 NAMES <- toupper(changed)
[01:29:27.366]                 args <- list()
[01:29:27.366]                 for (kk in seq_along(NAMES)) {
[01:29:27.366]                   name <- changed[[kk]]
[01:29:27.366]                   NAME <- NAMES[[kk]]
[01:29:27.366]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.366]                     next
[01:29:27.366]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.366]                 }
[01:29:27.366]                 NAMES <- toupper(added)
[01:29:27.366]                 for (kk in seq_along(NAMES)) {
[01:29:27.366]                   name <- added[[kk]]
[01:29:27.366]                   NAME <- NAMES[[kk]]
[01:29:27.366]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.366]                     next
[01:29:27.366]                   args[[name]] <- ""
[01:29:27.366]                 }
[01:29:27.366]                 NAMES <- toupper(removed)
[01:29:27.366]                 for (kk in seq_along(NAMES)) {
[01:29:27.366]                   name <- removed[[kk]]
[01:29:27.366]                   NAME <- NAMES[[kk]]
[01:29:27.366]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.366]                     next
[01:29:27.366]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.366]                 }
[01:29:27.366]                 if (length(args) > 0) 
[01:29:27.366]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.366]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.366]             }
[01:29:27.366]             else {
[01:29:27.366]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.366]             }
[01:29:27.366]             {
[01:29:27.366]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.366]                   0L) {
[01:29:27.366]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.366]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.366]                   base::options(opts)
[01:29:27.366]                 }
[01:29:27.366]                 {
[01:29:27.366]                   {
[01:29:27.366]                     base::assign(".Random.seed", c(10407L, -997816390L, 
[01:29:27.366]                     -1614775375L, 1388543034L, -889426559L, 1910868364L, 
[01:29:27.366]                     -2011626201L), envir = base::globalenv(), 
[01:29:27.366]                       inherits = FALSE)
[01:29:27.366]                     NULL
[01:29:27.366]                   }
[01:29:27.366]                   options(future.plan = NULL)
[01:29:27.366]                   if (is.na(NA_character_)) 
[01:29:27.366]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.366]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.366]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.366]                   {
[01:29:27.366]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.366]                     if (!future$lazy) 
[01:29:27.366]                       future <- run(future)
[01:29:27.366]                     invisible(future)
[01:29:27.366]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.366]                 }
[01:29:27.366]             }
[01:29:27.366]         }
[01:29:27.366]     })
[01:29:27.366]     if (TRUE) {
[01:29:27.366]         base::sink(type = "output", split = FALSE)
[01:29:27.366]         if (TRUE) {
[01:29:27.366]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.366]         }
[01:29:27.366]         else {
[01:29:27.366]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.366]         }
[01:29:27.366]         base::close(...future.stdout)
[01:29:27.366]         ...future.stdout <- NULL
[01:29:27.366]     }
[01:29:27.366]     ...future.result$conditions <- ...future.conditions
[01:29:27.366]     ...future.result$finished <- base::Sys.time()
[01:29:27.366]     ...future.result
[01:29:27.366] }
[01:29:27.369] assign_globals() ...
[01:29:27.369] List of 1
[01:29:27.369]  $ x: int [1:4] 0 1 2 3
[01:29:27.369]  - attr(*, "where")=List of 1
[01:29:27.369]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.369]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.369]  - attr(*, "resolved")= logi FALSE
[01:29:27.369]  - attr(*, "total_size")= num 64
[01:29:27.369]  - attr(*, "already-done")= logi TRUE
[01:29:27.372] - copied 'x' to environment
[01:29:27.373] assign_globals() ... done
[01:29:27.373] plan(): Setting new future strategy stack:
[01:29:27.373] List of future strategies:
[01:29:27.373] 1. sequential:
[01:29:27.373]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.373]    - tweaked: FALSE
[01:29:27.373]    - call: NULL
[01:29:27.374] plan(): nbrOfWorkers() = 1
[01:29:27.375] plan(): Setting new future strategy stack:
[01:29:27.375] List of future strategies:
[01:29:27.375] 1. sequential:
[01:29:27.375]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.375]    - tweaked: FALSE
[01:29:27.375]    - call: plan(strategy)
[01:29:27.376] plan(): nbrOfWorkers() = 1
[01:29:27.376] SequentialFuture started (and completed)
[01:29:27.376] - Launch lazy future ... done
[01:29:27.376] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_4-707243'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96cbb6538
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.378] resolve() on list ...
[01:29:27.378]  recursive: 0
[01:29:27.378]  length: 4
[01:29:27.378] 
[01:29:27.378] resolved() for 'SequentialFuture' ...
[01:29:27.378] - state: 'finished'
[01:29:27.379] - run: TRUE
[01:29:27.379] - result: 'FutureResult'
[01:29:27.379] resolved() for 'SequentialFuture' ... done
[01:29:27.379] Future #1
[01:29:27.380] signalConditionsASAP(SequentialFuture, pos=1) ...
[01:29:27.380] - nx: 4
[01:29:27.380] - relay: TRUE
[01:29:27.380] - stdout: TRUE
[01:29:27.380] - signal: TRUE
[01:29:27.381] - resignal: FALSE
[01:29:27.381] - force: TRUE
[01:29:27.381] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:27.381] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:27.381]  - until=1
[01:29:27.381]  - relaying element #1
[01:29:27.382] signalConditions() ...
[01:29:27.382]  - include = 'immediateCondition'
[01:29:27.382]  - exclude = 
[01:29:27.382]  - resignal = FALSE
[01:29:27.382]  - Number of conditions: 1
[01:29:27.382] signalConditions() ... done
[01:29:27.383] signalConditions() ...
[01:29:27.383]  - include = 'immediateCondition'
[01:29:27.383]  - exclude = 
[01:29:27.383]  - resignal = FALSE
[01:29:27.383]  - Number of conditions: 1
[01:29:27.384] signalConditions() ... done
[01:29:27.384] signalConditions() ...
[01:29:27.384]  - include = 'condition'
[01:29:27.384]  - exclude = 'immediateCondition'
[01:29:27.384]  - resignal = TRUE
[01:29:27.384]  - Number of conditions: 1
[01:29:27.385]  - Condition #1: 'RngFutureWarning', 'FutureWarning', 'warning', 'RngFutureCondition', 'FutureCondition', 'condition'
[01:29:27.385] signalConditions() ... done
[01:29:27.385] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:27.385] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:27.385] signalConditionsASAP(SequentialFuture, pos=1) ... done
<RngFutureWarning: UNRELIABLE VALUE: Future ('fsample_1-682326') unexpectedly generated random numbers without specifying argument 'seed'. There is a risk that those random numbers are not statistically sound and the overall results might be invalid. To fix this, specify 'seed=TRUE'. This ensures that proper, parallel-safe random numbers are produced via the L'Ecuyer-CMRG method. To disable this check, use 'seed=NULL', or set option 'future.rng.onMisuse' to "ignore".>


Future UUID: be7e55d5-a34a-cb37-c1f7-f9e5b6bdea1b


DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
SequentialFuture:
Label: 'fsample_1-682326'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96cbb6538
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Conditions captured: [n=1] 'RngFutureWarning'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'

DEBUG: END TROUBLESHOOTING HELP
[01:29:27.387] getGlobalsAndPackages() ...
[01:29:27.387] Searching for globals...
[01:29:27.388] - globals found: [3] '{', 'sample', 'x'
[01:29:27.388] Searching for globals ... DONE
[01:29:27.388] Resolving globals: FALSE
[01:29:27.389] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.389] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.390] - globals: [1] 'x'
[01:29:27.390] 
[01:29:27.390] getGlobalsAndPackages() ... DONE
[01:29:27.390] run() for 'Future' ...
[01:29:27.390] - state: 'created'
[01:29:27.391] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.391] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.391] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.391]   - Field: 'label'
[01:29:27.392]   - Field: 'local'
[01:29:27.392]   - Field: 'owner'
[01:29:27.392]   - Field: 'envir'
[01:29:27.392]   - Field: 'packages'
[01:29:27.392]   - Field: 'gc'
[01:29:27.392]   - Field: 'conditions'
[01:29:27.393]   - Field: 'expr'
[01:29:27.393]   - Field: 'uuid'
[01:29:27.393]   - Field: 'seed'
[01:29:27.393]   - Field: 'version'
[01:29:27.393]   - Field: 'result'
[01:29:27.394]   - Field: 'asynchronous'
[01:29:27.394]   - Field: 'calls'
[01:29:27.394]   - Field: 'globals'
[01:29:27.394]   - Field: 'stdout'
[01:29:27.394]   - Field: 'earlySignal'
[01:29:27.394]   - Field: 'lazy'
[01:29:27.395]   - Field: 'state'
[01:29:27.395] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.395] - Launch lazy future ...
[01:29:27.395] Packages needed by the future expression (n = 0): <none>
[01:29:27.395] Packages needed by future strategies (n = 0): <none>
[01:29:27.396] {
[01:29:27.396]     {
[01:29:27.396]         {
[01:29:27.396]             ...future.startTime <- base::Sys.time()
[01:29:27.396]             {
[01:29:27.396]                 {
[01:29:27.396]                   {
[01:29:27.396]                     base::local({
[01:29:27.396]                       has_future <- base::requireNamespace("future", 
[01:29:27.396]                         quietly = TRUE)
[01:29:27.396]                       if (has_future) {
[01:29:27.396]                         ns <- base::getNamespace("future")
[01:29:27.396]                         version <- ns[[".package"]][["version"]]
[01:29:27.396]                         if (is.null(version)) 
[01:29:27.396]                           version <- utils::packageVersion("future")
[01:29:27.396]                       }
[01:29:27.396]                       else {
[01:29:27.396]                         version <- NULL
[01:29:27.396]                       }
[01:29:27.396]                       if (!has_future || version < "1.8.0") {
[01:29:27.396]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.396]                           "", base::R.version$version.string), 
[01:29:27.396]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.396]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.396]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.396]                             "release", "version")], collapse = " "), 
[01:29:27.396]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.396]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.396]                           info)
[01:29:27.396]                         info <- base::paste(info, collapse = "; ")
[01:29:27.396]                         if (!has_future) {
[01:29:27.396]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.396]                             info)
[01:29:27.396]                         }
[01:29:27.396]                         else {
[01:29:27.396]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.396]                             info, version)
[01:29:27.396]                         }
[01:29:27.396]                         base::stop(msg)
[01:29:27.396]                       }
[01:29:27.396]                     })
[01:29:27.396]                   }
[01:29:27.396]                   options(future.plan = NULL)
[01:29:27.396]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.396]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.396]                 }
[01:29:27.396]                 ...future.workdir <- getwd()
[01:29:27.396]             }
[01:29:27.396]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.396]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.396]         }
[01:29:27.396]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.396]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.396]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.396]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.396]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.396]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.396]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.396]             base::names(...future.oldOptions))
[01:29:27.396]     }
[01:29:27.396]     if (FALSE) {
[01:29:27.396]     }
[01:29:27.396]     else {
[01:29:27.396]         if (TRUE) {
[01:29:27.396]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.396]                 open = "w")
[01:29:27.396]         }
[01:29:27.396]         else {
[01:29:27.396]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.396]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.396]         }
[01:29:27.396]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.396]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.396]             base::sink(type = "output", split = FALSE)
[01:29:27.396]             base::close(...future.stdout)
[01:29:27.396]         }, add = TRUE)
[01:29:27.396]     }
[01:29:27.396]     ...future.frame <- base::sys.nframe()
[01:29:27.396]     ...future.conditions <- base::list()
[01:29:27.396]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.396]     if (FALSE) {
[01:29:27.396]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.396]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.396]     }
[01:29:27.396]     ...future.result <- base::tryCatch({
[01:29:27.396]         base::withCallingHandlers({
[01:29:27.396]             ...future.value <- base::withVisible(base::local({
[01:29:27.396]                 sample(x, size = 1L)
[01:29:27.396]             }))
[01:29:27.396]             future::FutureResult(value = ...future.value$value, 
[01:29:27.396]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.396]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.396]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.396]                     ...future.globalenv.names))
[01:29:27.396]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.396]         }, condition = base::local({
[01:29:27.396]             c <- base::c
[01:29:27.396]             inherits <- base::inherits
[01:29:27.396]             invokeRestart <- base::invokeRestart
[01:29:27.396]             length <- base::length
[01:29:27.396]             list <- base::list
[01:29:27.396]             seq.int <- base::seq.int
[01:29:27.396]             signalCondition <- base::signalCondition
[01:29:27.396]             sys.calls <- base::sys.calls
[01:29:27.396]             `[[` <- base::`[[`
[01:29:27.396]             `+` <- base::`+`
[01:29:27.396]             `<<-` <- base::`<<-`
[01:29:27.396]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.396]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.396]                   3L)]
[01:29:27.396]             }
[01:29:27.396]             function(cond) {
[01:29:27.396]                 is_error <- inherits(cond, "error")
[01:29:27.396]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.396]                   NULL)
[01:29:27.396]                 if (is_error) {
[01:29:27.396]                   sessionInformation <- function() {
[01:29:27.396]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.396]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.396]                       search = base::search(), system = base::Sys.info())
[01:29:27.396]                   }
[01:29:27.396]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.396]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.396]                     cond$call), session = sessionInformation(), 
[01:29:27.396]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.396]                   signalCondition(cond)
[01:29:27.396]                 }
[01:29:27.396]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.396]                 "immediateCondition"))) {
[01:29:27.396]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.396]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.396]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.396]                   if (TRUE && !signal) {
[01:29:27.396]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.396]                     {
[01:29:27.396]                       inherits <- base::inherits
[01:29:27.396]                       invokeRestart <- base::invokeRestart
[01:29:27.396]                       is.null <- base::is.null
[01:29:27.396]                       muffled <- FALSE
[01:29:27.396]                       if (inherits(cond, "message")) {
[01:29:27.396]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.396]                         if (muffled) 
[01:29:27.396]                           invokeRestart("muffleMessage")
[01:29:27.396]                       }
[01:29:27.396]                       else if (inherits(cond, "warning")) {
[01:29:27.396]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.396]                         if (muffled) 
[01:29:27.396]                           invokeRestart("muffleWarning")
[01:29:27.396]                       }
[01:29:27.396]                       else if (inherits(cond, "condition")) {
[01:29:27.396]                         if (!is.null(pattern)) {
[01:29:27.396]                           computeRestarts <- base::computeRestarts
[01:29:27.396]                           grepl <- base::grepl
[01:29:27.396]                           restarts <- computeRestarts(cond)
[01:29:27.396]                           for (restart in restarts) {
[01:29:27.396]                             name <- restart$name
[01:29:27.396]                             if (is.null(name)) 
[01:29:27.396]                               next
[01:29:27.396]                             if (!grepl(pattern, name)) 
[01:29:27.396]                               next
[01:29:27.396]                             invokeRestart(restart)
[01:29:27.396]                             muffled <- TRUE
[01:29:27.396]                             break
[01:29:27.396]                           }
[01:29:27.396]                         }
[01:29:27.396]                       }
[01:29:27.396]                       invisible(muffled)
[01:29:27.396]                     }
[01:29:27.396]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.396]                   }
[01:29:27.396]                 }
[01:29:27.396]                 else {
[01:29:27.396]                   if (TRUE) {
[01:29:27.396]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.396]                     {
[01:29:27.396]                       inherits <- base::inherits
[01:29:27.396]                       invokeRestart <- base::invokeRestart
[01:29:27.396]                       is.null <- base::is.null
[01:29:27.396]                       muffled <- FALSE
[01:29:27.396]                       if (inherits(cond, "message")) {
[01:29:27.396]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.396]                         if (muffled) 
[01:29:27.396]                           invokeRestart("muffleMessage")
[01:29:27.396]                       }
[01:29:27.396]                       else if (inherits(cond, "warning")) {
[01:29:27.396]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.396]                         if (muffled) 
[01:29:27.396]                           invokeRestart("muffleWarning")
[01:29:27.396]                       }
[01:29:27.396]                       else if (inherits(cond, "condition")) {
[01:29:27.396]                         if (!is.null(pattern)) {
[01:29:27.396]                           computeRestarts <- base::computeRestarts
[01:29:27.396]                           grepl <- base::grepl
[01:29:27.396]                           restarts <- computeRestarts(cond)
[01:29:27.396]                           for (restart in restarts) {
[01:29:27.396]                             name <- restart$name
[01:29:27.396]                             if (is.null(name)) 
[01:29:27.396]                               next
[01:29:27.396]                             if (!grepl(pattern, name)) 
[01:29:27.396]                               next
[01:29:27.396]                             invokeRestart(restart)
[01:29:27.396]                             muffled <- TRUE
[01:29:27.396]                             break
[01:29:27.396]                           }
[01:29:27.396]                         }
[01:29:27.396]                       }
[01:29:27.396]                       invisible(muffled)
[01:29:27.396]                     }
[01:29:27.396]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.396]                   }
[01:29:27.396]                 }
[01:29:27.396]             }
[01:29:27.396]         }))
[01:29:27.396]     }, error = function(ex) {
[01:29:27.396]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.396]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.396]                 ...future.rng), started = ...future.startTime, 
[01:29:27.396]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.396]             version = "1.8"), class = "FutureResult")
[01:29:27.396]     }, finally = {
[01:29:27.396]         if (!identical(...future.workdir, getwd())) 
[01:29:27.396]             setwd(...future.workdir)
[01:29:27.396]         {
[01:29:27.396]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.396]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.396]             }
[01:29:27.396]             base::options(...future.oldOptions)
[01:29:27.396]             if (.Platform$OS.type == "windows") {
[01:29:27.396]                 old_names <- names(...future.oldEnvVars)
[01:29:27.396]                 envs <- base::Sys.getenv()
[01:29:27.396]                 names <- names(envs)
[01:29:27.396]                 common <- intersect(names, old_names)
[01:29:27.396]                 added <- setdiff(names, old_names)
[01:29:27.396]                 removed <- setdiff(old_names, names)
[01:29:27.396]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.396]                   envs[common]]
[01:29:27.396]                 NAMES <- toupper(changed)
[01:29:27.396]                 args <- list()
[01:29:27.396]                 for (kk in seq_along(NAMES)) {
[01:29:27.396]                   name <- changed[[kk]]
[01:29:27.396]                   NAME <- NAMES[[kk]]
[01:29:27.396]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.396]                     next
[01:29:27.396]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.396]                 }
[01:29:27.396]                 NAMES <- toupper(added)
[01:29:27.396]                 for (kk in seq_along(NAMES)) {
[01:29:27.396]                   name <- added[[kk]]
[01:29:27.396]                   NAME <- NAMES[[kk]]
[01:29:27.396]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.396]                     next
[01:29:27.396]                   args[[name]] <- ""
[01:29:27.396]                 }
[01:29:27.396]                 NAMES <- toupper(removed)
[01:29:27.396]                 for (kk in seq_along(NAMES)) {
[01:29:27.396]                   name <- removed[[kk]]
[01:29:27.396]                   NAME <- NAMES[[kk]]
[01:29:27.396]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.396]                     next
[01:29:27.396]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.396]                 }
[01:29:27.396]                 if (length(args) > 0) 
[01:29:27.396]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.396]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.396]             }
[01:29:27.396]             else {
[01:29:27.396]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.396]             }
[01:29:27.396]             {
[01:29:27.396]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.396]                   0L) {
[01:29:27.396]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.396]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.396]                   base::options(opts)
[01:29:27.396]                 }
[01:29:27.396]                 {
[01:29:27.396]                   {
[01:29:27.396]                     base::assign(".Random.seed", c(10407L, 239264608L, 
[01:29:27.396]                     -335112117L, 1547161855L, 1641764833L, 1205356201L, 
[01:29:27.396]                     12529069L), envir = base::globalenv(), inherits = FALSE)
[01:29:27.396]                     NULL
[01:29:27.396]                   }
[01:29:27.396]                   options(future.plan = NULL)
[01:29:27.396]                   if (is.na(NA_character_)) 
[01:29:27.396]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.396]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.396]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.396]                   {
[01:29:27.396]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.396]                     if (!future$lazy) 
[01:29:27.396]                       future <- run(future)
[01:29:27.396]                     invisible(future)
[01:29:27.396]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.396]                 }
[01:29:27.396]             }
[01:29:27.396]         }
[01:29:27.396]     })
[01:29:27.396]     if (TRUE) {
[01:29:27.396]         base::sink(type = "output", split = FALSE)
[01:29:27.396]         if (TRUE) {
[01:29:27.396]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.396]         }
[01:29:27.396]         else {
[01:29:27.396]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.396]         }
[01:29:27.396]         base::close(...future.stdout)
[01:29:27.396]         ...future.stdout <- NULL
[01:29:27.396]     }
[01:29:27.396]     ...future.result$conditions <- ...future.conditions
[01:29:27.396]     ...future.result$finished <- base::Sys.time()
[01:29:27.396]     ...future.result
[01:29:27.396] }
[01:29:27.400] assign_globals() ...
[01:29:27.400] List of 1
[01:29:27.400]  $ x: int [1:4] 0 1 2 3
[01:29:27.400]  - attr(*, "where")=List of 1
[01:29:27.400]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.400]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.400]  - attr(*, "resolved")= logi FALSE
[01:29:27.400]  - attr(*, "total_size")= num 64
[01:29:27.400]  - attr(*, "already-done")= logi TRUE
[01:29:27.403] - copied 'x' to environment
[01:29:27.403] assign_globals() ... done
[01:29:27.405] plan(): Setting new future strategy stack:
[01:29:27.405] List of future strategies:
[01:29:27.405] 1. sequential:
[01:29:27.405]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.405]    - tweaked: FALSE
[01:29:27.405]    - call: NULL
[01:29:27.405] plan(): nbrOfWorkers() = 1
[01:29:27.406] plan(): Setting new future strategy stack:
[01:29:27.407] List of future strategies:
[01:29:27.407] 1. sequential:
[01:29:27.407]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.407]    - tweaked: FALSE
[01:29:27.407]    - call: plan(strategy)
[01:29:27.407] plan(): nbrOfWorkers() = 1
[01:29:27.408] SequentialFuture started (and completed)
[01:29:27.408] - Launch lazy future ... done
[01:29:27.408] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_1-940921'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96be7df10
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.409] getGlobalsAndPackages() ...
[01:29:27.409] Searching for globals...
[01:29:27.410] - globals found: [3] '{', 'sample', 'x'
[01:29:27.411] Searching for globals ... DONE
[01:29:27.411] Resolving globals: FALSE
[01:29:27.411] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.412] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.412] - globals: [1] 'x'
[01:29:27.412] 
[01:29:27.412] getGlobalsAndPackages() ... DONE
[01:29:27.413] run() for 'Future' ...
[01:29:27.413] - state: 'created'
[01:29:27.413] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.413] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.413] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.414]   - Field: 'label'
[01:29:27.414]   - Field: 'local'
[01:29:27.414]   - Field: 'owner'
[01:29:27.414]   - Field: 'envir'
[01:29:27.414]   - Field: 'packages'
[01:29:27.415]   - Field: 'gc'
[01:29:27.415]   - Field: 'conditions'
[01:29:27.415]   - Field: 'expr'
[01:29:27.415]   - Field: 'uuid'
[01:29:27.415]   - Field: 'seed'
[01:29:27.415]   - Field: 'version'
[01:29:27.416]   - Field: 'result'
[01:29:27.416]   - Field: 'asynchronous'
[01:29:27.416]   - Field: 'calls'
[01:29:27.416]   - Field: 'globals'
[01:29:27.416]   - Field: 'stdout'
[01:29:27.416]   - Field: 'earlySignal'
[01:29:27.417]   - Field: 'lazy'
[01:29:27.417]   - Field: 'state'
[01:29:27.417] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.417] - Launch lazy future ...
[01:29:27.417] Packages needed by the future expression (n = 0): <none>
[01:29:27.418] Packages needed by future strategies (n = 0): <none>
[01:29:27.418] {
[01:29:27.418]     {
[01:29:27.418]         {
[01:29:27.418]             ...future.startTime <- base::Sys.time()
[01:29:27.418]             {
[01:29:27.418]                 {
[01:29:27.418]                   {
[01:29:27.418]                     base::local({
[01:29:27.418]                       has_future <- base::requireNamespace("future", 
[01:29:27.418]                         quietly = TRUE)
[01:29:27.418]                       if (has_future) {
[01:29:27.418]                         ns <- base::getNamespace("future")
[01:29:27.418]                         version <- ns[[".package"]][["version"]]
[01:29:27.418]                         if (is.null(version)) 
[01:29:27.418]                           version <- utils::packageVersion("future")
[01:29:27.418]                       }
[01:29:27.418]                       else {
[01:29:27.418]                         version <- NULL
[01:29:27.418]                       }
[01:29:27.418]                       if (!has_future || version < "1.8.0") {
[01:29:27.418]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.418]                           "", base::R.version$version.string), 
[01:29:27.418]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.418]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.418]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.418]                             "release", "version")], collapse = " "), 
[01:29:27.418]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.418]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.418]                           info)
[01:29:27.418]                         info <- base::paste(info, collapse = "; ")
[01:29:27.418]                         if (!has_future) {
[01:29:27.418]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.418]                             info)
[01:29:27.418]                         }
[01:29:27.418]                         else {
[01:29:27.418]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.418]                             info, version)
[01:29:27.418]                         }
[01:29:27.418]                         base::stop(msg)
[01:29:27.418]                       }
[01:29:27.418]                     })
[01:29:27.418]                   }
[01:29:27.418]                   options(future.plan = NULL)
[01:29:27.418]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.418]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.418]                 }
[01:29:27.418]                 ...future.workdir <- getwd()
[01:29:27.418]             }
[01:29:27.418]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.418]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.418]         }
[01:29:27.418]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.418]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.418]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.418]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.418]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.418]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.418]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.418]             base::names(...future.oldOptions))
[01:29:27.418]     }
[01:29:27.418]     if (FALSE) {
[01:29:27.418]     }
[01:29:27.418]     else {
[01:29:27.418]         if (TRUE) {
[01:29:27.418]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.418]                 open = "w")
[01:29:27.418]         }
[01:29:27.418]         else {
[01:29:27.418]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.418]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.418]         }
[01:29:27.418]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.418]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.418]             base::sink(type = "output", split = FALSE)
[01:29:27.418]             base::close(...future.stdout)
[01:29:27.418]         }, add = TRUE)
[01:29:27.418]     }
[01:29:27.418]     ...future.frame <- base::sys.nframe()
[01:29:27.418]     ...future.conditions <- base::list()
[01:29:27.418]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.418]     if (FALSE) {
[01:29:27.418]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.418]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.418]     }
[01:29:27.418]     ...future.result <- base::tryCatch({
[01:29:27.418]         base::withCallingHandlers({
[01:29:27.418]             ...future.value <- base::withVisible(base::local({
[01:29:27.418]                 sample(x, size = 1L)
[01:29:27.418]             }))
[01:29:27.418]             future::FutureResult(value = ...future.value$value, 
[01:29:27.418]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.418]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.418]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.418]                     ...future.globalenv.names))
[01:29:27.418]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.418]         }, condition = base::local({
[01:29:27.418]             c <- base::c
[01:29:27.418]             inherits <- base::inherits
[01:29:27.418]             invokeRestart <- base::invokeRestart
[01:29:27.418]             length <- base::length
[01:29:27.418]             list <- base::list
[01:29:27.418]             seq.int <- base::seq.int
[01:29:27.418]             signalCondition <- base::signalCondition
[01:29:27.418]             sys.calls <- base::sys.calls
[01:29:27.418]             `[[` <- base::`[[`
[01:29:27.418]             `+` <- base::`+`
[01:29:27.418]             `<<-` <- base::`<<-`
[01:29:27.418]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.418]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.418]                   3L)]
[01:29:27.418]             }
[01:29:27.418]             function(cond) {
[01:29:27.418]                 is_error <- inherits(cond, "error")
[01:29:27.418]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.418]                   NULL)
[01:29:27.418]                 if (is_error) {
[01:29:27.418]                   sessionInformation <- function() {
[01:29:27.418]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.418]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.418]                       search = base::search(), system = base::Sys.info())
[01:29:27.418]                   }
[01:29:27.418]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.418]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.418]                     cond$call), session = sessionInformation(), 
[01:29:27.418]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.418]                   signalCondition(cond)
[01:29:27.418]                 }
[01:29:27.418]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.418]                 "immediateCondition"))) {
[01:29:27.418]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.418]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.418]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.418]                   if (TRUE && !signal) {
[01:29:27.418]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.418]                     {
[01:29:27.418]                       inherits <- base::inherits
[01:29:27.418]                       invokeRestart <- base::invokeRestart
[01:29:27.418]                       is.null <- base::is.null
[01:29:27.418]                       muffled <- FALSE
[01:29:27.418]                       if (inherits(cond, "message")) {
[01:29:27.418]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.418]                         if (muffled) 
[01:29:27.418]                           invokeRestart("muffleMessage")
[01:29:27.418]                       }
[01:29:27.418]                       else if (inherits(cond, "warning")) {
[01:29:27.418]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.418]                         if (muffled) 
[01:29:27.418]                           invokeRestart("muffleWarning")
[01:29:27.418]                       }
[01:29:27.418]                       else if (inherits(cond, "condition")) {
[01:29:27.418]                         if (!is.null(pattern)) {
[01:29:27.418]                           computeRestarts <- base::computeRestarts
[01:29:27.418]                           grepl <- base::grepl
[01:29:27.418]                           restarts <- computeRestarts(cond)
[01:29:27.418]                           for (restart in restarts) {
[01:29:27.418]                             name <- restart$name
[01:29:27.418]                             if (is.null(name)) 
[01:29:27.418]                               next
[01:29:27.418]                             if (!grepl(pattern, name)) 
[01:29:27.418]                               next
[01:29:27.418]                             invokeRestart(restart)
[01:29:27.418]                             muffled <- TRUE
[01:29:27.418]                             break
[01:29:27.418]                           }
[01:29:27.418]                         }
[01:29:27.418]                       }
[01:29:27.418]                       invisible(muffled)
[01:29:27.418]                     }
[01:29:27.418]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.418]                   }
[01:29:27.418]                 }
[01:29:27.418]                 else {
[01:29:27.418]                   if (TRUE) {
[01:29:27.418]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.418]                     {
[01:29:27.418]                       inherits <- base::inherits
[01:29:27.418]                       invokeRestart <- base::invokeRestart
[01:29:27.418]                       is.null <- base::is.null
[01:29:27.418]                       muffled <- FALSE
[01:29:27.418]                       if (inherits(cond, "message")) {
[01:29:27.418]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.418]                         if (muffled) 
[01:29:27.418]                           invokeRestart("muffleMessage")
[01:29:27.418]                       }
[01:29:27.418]                       else if (inherits(cond, "warning")) {
[01:29:27.418]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.418]                         if (muffled) 
[01:29:27.418]                           invokeRestart("muffleWarning")
[01:29:27.418]                       }
[01:29:27.418]                       else if (inherits(cond, "condition")) {
[01:29:27.418]                         if (!is.null(pattern)) {
[01:29:27.418]                           computeRestarts <- base::computeRestarts
[01:29:27.418]                           grepl <- base::grepl
[01:29:27.418]                           restarts <- computeRestarts(cond)
[01:29:27.418]                           for (restart in restarts) {
[01:29:27.418]                             name <- restart$name
[01:29:27.418]                             if (is.null(name)) 
[01:29:27.418]                               next
[01:29:27.418]                             if (!grepl(pattern, name)) 
[01:29:27.418]                               next
[01:29:27.418]                             invokeRestart(restart)
[01:29:27.418]                             muffled <- TRUE
[01:29:27.418]                             break
[01:29:27.418]                           }
[01:29:27.418]                         }
[01:29:27.418]                       }
[01:29:27.418]                       invisible(muffled)
[01:29:27.418]                     }
[01:29:27.418]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.418]                   }
[01:29:27.418]                 }
[01:29:27.418]             }
[01:29:27.418]         }))
[01:29:27.418]     }, error = function(ex) {
[01:29:27.418]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.418]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.418]                 ...future.rng), started = ...future.startTime, 
[01:29:27.418]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.418]             version = "1.8"), class = "FutureResult")
[01:29:27.418]     }, finally = {
[01:29:27.418]         if (!identical(...future.workdir, getwd())) 
[01:29:27.418]             setwd(...future.workdir)
[01:29:27.418]         {
[01:29:27.418]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.418]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.418]             }
[01:29:27.418]             base::options(...future.oldOptions)
[01:29:27.418]             if (.Platform$OS.type == "windows") {
[01:29:27.418]                 old_names <- names(...future.oldEnvVars)
[01:29:27.418]                 envs <- base::Sys.getenv()
[01:29:27.418]                 names <- names(envs)
[01:29:27.418]                 common <- intersect(names, old_names)
[01:29:27.418]                 added <- setdiff(names, old_names)
[01:29:27.418]                 removed <- setdiff(old_names, names)
[01:29:27.418]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.418]                   envs[common]]
[01:29:27.418]                 NAMES <- toupper(changed)
[01:29:27.418]                 args <- list()
[01:29:27.418]                 for (kk in seq_along(NAMES)) {
[01:29:27.418]                   name <- changed[[kk]]
[01:29:27.418]                   NAME <- NAMES[[kk]]
[01:29:27.418]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.418]                     next
[01:29:27.418]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.418]                 }
[01:29:27.418]                 NAMES <- toupper(added)
[01:29:27.418]                 for (kk in seq_along(NAMES)) {
[01:29:27.418]                   name <- added[[kk]]
[01:29:27.418]                   NAME <- NAMES[[kk]]
[01:29:27.418]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.418]                     next
[01:29:27.418]                   args[[name]] <- ""
[01:29:27.418]                 }
[01:29:27.418]                 NAMES <- toupper(removed)
[01:29:27.418]                 for (kk in seq_along(NAMES)) {
[01:29:27.418]                   name <- removed[[kk]]
[01:29:27.418]                   NAME <- NAMES[[kk]]
[01:29:27.418]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.418]                     next
[01:29:27.418]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.418]                 }
[01:29:27.418]                 if (length(args) > 0) 
[01:29:27.418]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.418]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.418]             }
[01:29:27.418]             else {
[01:29:27.418]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.418]             }
[01:29:27.418]             {
[01:29:27.418]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.418]                   0L) {
[01:29:27.418]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.418]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.418]                   base::options(opts)
[01:29:27.418]                 }
[01:29:27.418]                 {
[01:29:27.418]                   {
[01:29:27.418]                     base::assign(".Random.seed", c(10407L, 1547161855L, 
[01:29:27.418]                     2030137722L, -2113589453L, 12529069L, 1564813159L, 
[01:29:27.418]                     -540026874L), envir = base::globalenv(), 
[01:29:27.418]                       inherits = FALSE)
[01:29:27.418]                     NULL
[01:29:27.418]                   }
[01:29:27.418]                   options(future.plan = NULL)
[01:29:27.418]                   if (is.na(NA_character_)) 
[01:29:27.418]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.418]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.418]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.418]                   {
[01:29:27.418]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.418]                     if (!future$lazy) 
[01:29:27.418]                       future <- run(future)
[01:29:27.418]                     invisible(future)
[01:29:27.418]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.418]                 }
[01:29:27.418]             }
[01:29:27.418]         }
[01:29:27.418]     })
[01:29:27.418]     if (TRUE) {
[01:29:27.418]         base::sink(type = "output", split = FALSE)
[01:29:27.418]         if (TRUE) {
[01:29:27.418]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.418]         }
[01:29:27.418]         else {
[01:29:27.418]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.418]         }
[01:29:27.418]         base::close(...future.stdout)
[01:29:27.418]         ...future.stdout <- NULL
[01:29:27.418]     }
[01:29:27.418]     ...future.result$conditions <- ...future.conditions
[01:29:27.418]     ...future.result$finished <- base::Sys.time()
[01:29:27.418]     ...future.result
[01:29:27.418] }
[01:29:27.422] assign_globals() ...
[01:29:27.422] List of 1
[01:29:27.422]  $ x: int [1:4] 0 1 2 3
[01:29:27.422]  - attr(*, "where")=List of 1
[01:29:27.422]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.422]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.422]  - attr(*, "resolved")= logi FALSE
[01:29:27.422]  - attr(*, "total_size")= num 64
[01:29:27.422]  - attr(*, "already-done")= logi TRUE
[01:29:27.425] - copied 'x' to environment
[01:29:27.425] assign_globals() ... done
[01:29:27.426] plan(): Setting new future strategy stack:
[01:29:27.426] List of future strategies:
[01:29:27.426] 1. sequential:
[01:29:27.426]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.426]    - tweaked: FALSE
[01:29:27.426]    - call: NULL
[01:29:27.426] plan(): nbrOfWorkers() = 1
[01:29:27.428] plan(): Setting new future strategy stack:
[01:29:27.428] List of future strategies:
[01:29:27.428] 1. sequential:
[01:29:27.428]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.428]    - tweaked: FALSE
[01:29:27.428]    - call: plan(strategy)
[01:29:27.429] plan(): nbrOfWorkers() = 1
[01:29:27.429] SequentialFuture started (and completed)
[01:29:27.429] - Launch lazy future ... done
[01:29:27.429] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_2-827958'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96be7df10
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.430] getGlobalsAndPackages() ...
[01:29:27.430] Searching for globals...
[01:29:27.431] - globals found: [3] '{', 'sample', 'x'
[01:29:27.432] Searching for globals ... DONE
[01:29:27.432] Resolving globals: FALSE
[01:29:27.432] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.433] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.433] - globals: [1] 'x'
[01:29:27.433] 
[01:29:27.433] getGlobalsAndPackages() ... DONE
[01:29:27.434] run() for 'Future' ...
[01:29:27.434] - state: 'created'
[01:29:27.434] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.434] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.435] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.435]   - Field: 'label'
[01:29:27.435]   - Field: 'local'
[01:29:27.435]   - Field: 'owner'
[01:29:27.435]   - Field: 'envir'
[01:29:27.435]   - Field: 'packages'
[01:29:27.436]   - Field: 'gc'
[01:29:27.436]   - Field: 'conditions'
[01:29:27.436]   - Field: 'expr'
[01:29:27.436]   - Field: 'uuid'
[01:29:27.436]   - Field: 'seed'
[01:29:27.437]   - Field: 'version'
[01:29:27.437]   - Field: 'result'
[01:29:27.437]   - Field: 'asynchronous'
[01:29:27.437]   - Field: 'calls'
[01:29:27.437]   - Field: 'globals'
[01:29:27.437]   - Field: 'stdout'
[01:29:27.438]   - Field: 'earlySignal'
[01:29:27.438]   - Field: 'lazy'
[01:29:27.438]   - Field: 'state'
[01:29:27.438] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.438] - Launch lazy future ...
[01:29:27.439] Packages needed by the future expression (n = 0): <none>
[01:29:27.439] Packages needed by future strategies (n = 0): <none>
[01:29:27.440] {
[01:29:27.440]     {
[01:29:27.440]         {
[01:29:27.440]             ...future.startTime <- base::Sys.time()
[01:29:27.440]             {
[01:29:27.440]                 {
[01:29:27.440]                   {
[01:29:27.440]                     base::local({
[01:29:27.440]                       has_future <- base::requireNamespace("future", 
[01:29:27.440]                         quietly = TRUE)
[01:29:27.440]                       if (has_future) {
[01:29:27.440]                         ns <- base::getNamespace("future")
[01:29:27.440]                         version <- ns[[".package"]][["version"]]
[01:29:27.440]                         if (is.null(version)) 
[01:29:27.440]                           version <- utils::packageVersion("future")
[01:29:27.440]                       }
[01:29:27.440]                       else {
[01:29:27.440]                         version <- NULL
[01:29:27.440]                       }
[01:29:27.440]                       if (!has_future || version < "1.8.0") {
[01:29:27.440]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.440]                           "", base::R.version$version.string), 
[01:29:27.440]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.440]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.440]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.440]                             "release", "version")], collapse = " "), 
[01:29:27.440]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.440]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.440]                           info)
[01:29:27.440]                         info <- base::paste(info, collapse = "; ")
[01:29:27.440]                         if (!has_future) {
[01:29:27.440]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.440]                             info)
[01:29:27.440]                         }
[01:29:27.440]                         else {
[01:29:27.440]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.440]                             info, version)
[01:29:27.440]                         }
[01:29:27.440]                         base::stop(msg)
[01:29:27.440]                       }
[01:29:27.440]                     })
[01:29:27.440]                   }
[01:29:27.440]                   options(future.plan = NULL)
[01:29:27.440]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.440]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.440]                 }
[01:29:27.440]                 ...future.workdir <- getwd()
[01:29:27.440]             }
[01:29:27.440]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.440]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.440]         }
[01:29:27.440]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.440]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.440]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.440]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.440]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.440]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.440]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.440]             base::names(...future.oldOptions))
[01:29:27.440]     }
[01:29:27.440]     if (FALSE) {
[01:29:27.440]     }
[01:29:27.440]     else {
[01:29:27.440]         if (TRUE) {
[01:29:27.440]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.440]                 open = "w")
[01:29:27.440]         }
[01:29:27.440]         else {
[01:29:27.440]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.440]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.440]         }
[01:29:27.440]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.440]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.440]             base::sink(type = "output", split = FALSE)
[01:29:27.440]             base::close(...future.stdout)
[01:29:27.440]         }, add = TRUE)
[01:29:27.440]     }
[01:29:27.440]     ...future.frame <- base::sys.nframe()
[01:29:27.440]     ...future.conditions <- base::list()
[01:29:27.440]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.440]     if (FALSE) {
[01:29:27.440]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.440]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.440]     }
[01:29:27.440]     ...future.result <- base::tryCatch({
[01:29:27.440]         base::withCallingHandlers({
[01:29:27.440]             ...future.value <- base::withVisible(base::local({
[01:29:27.440]                 sample(x, size = 1L)
[01:29:27.440]             }))
[01:29:27.440]             future::FutureResult(value = ...future.value$value, 
[01:29:27.440]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.440]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.440]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.440]                     ...future.globalenv.names))
[01:29:27.440]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.440]         }, condition = base::local({
[01:29:27.440]             c <- base::c
[01:29:27.440]             inherits <- base::inherits
[01:29:27.440]             invokeRestart <- base::invokeRestart
[01:29:27.440]             length <- base::length
[01:29:27.440]             list <- base::list
[01:29:27.440]             seq.int <- base::seq.int
[01:29:27.440]             signalCondition <- base::signalCondition
[01:29:27.440]             sys.calls <- base::sys.calls
[01:29:27.440]             `[[` <- base::`[[`
[01:29:27.440]             `+` <- base::`+`
[01:29:27.440]             `<<-` <- base::`<<-`
[01:29:27.440]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.440]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.440]                   3L)]
[01:29:27.440]             }
[01:29:27.440]             function(cond) {
[01:29:27.440]                 is_error <- inherits(cond, "error")
[01:29:27.440]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.440]                   NULL)
[01:29:27.440]                 if (is_error) {
[01:29:27.440]                   sessionInformation <- function() {
[01:29:27.440]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.440]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.440]                       search = base::search(), system = base::Sys.info())
[01:29:27.440]                   }
[01:29:27.440]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.440]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.440]                     cond$call), session = sessionInformation(), 
[01:29:27.440]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.440]                   signalCondition(cond)
[01:29:27.440]                 }
[01:29:27.440]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.440]                 "immediateCondition"))) {
[01:29:27.440]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.440]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.440]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.440]                   if (TRUE && !signal) {
[01:29:27.440]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.440]                     {
[01:29:27.440]                       inherits <- base::inherits
[01:29:27.440]                       invokeRestart <- base::invokeRestart
[01:29:27.440]                       is.null <- base::is.null
[01:29:27.440]                       muffled <- FALSE
[01:29:27.440]                       if (inherits(cond, "message")) {
[01:29:27.440]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.440]                         if (muffled) 
[01:29:27.440]                           invokeRestart("muffleMessage")
[01:29:27.440]                       }
[01:29:27.440]                       else if (inherits(cond, "warning")) {
[01:29:27.440]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.440]                         if (muffled) 
[01:29:27.440]                           invokeRestart("muffleWarning")
[01:29:27.440]                       }
[01:29:27.440]                       else if (inherits(cond, "condition")) {
[01:29:27.440]                         if (!is.null(pattern)) {
[01:29:27.440]                           computeRestarts <- base::computeRestarts
[01:29:27.440]                           grepl <- base::grepl
[01:29:27.440]                           restarts <- computeRestarts(cond)
[01:29:27.440]                           for (restart in restarts) {
[01:29:27.440]                             name <- restart$name
[01:29:27.440]                             if (is.null(name)) 
[01:29:27.440]                               next
[01:29:27.440]                             if (!grepl(pattern, name)) 
[01:29:27.440]                               next
[01:29:27.440]                             invokeRestart(restart)
[01:29:27.440]                             muffled <- TRUE
[01:29:27.440]                             break
[01:29:27.440]                           }
[01:29:27.440]                         }
[01:29:27.440]                       }
[01:29:27.440]                       invisible(muffled)
[01:29:27.440]                     }
[01:29:27.440]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.440]                   }
[01:29:27.440]                 }
[01:29:27.440]                 else {
[01:29:27.440]                   if (TRUE) {
[01:29:27.440]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.440]                     {
[01:29:27.440]                       inherits <- base::inherits
[01:29:27.440]                       invokeRestart <- base::invokeRestart
[01:29:27.440]                       is.null <- base::is.null
[01:29:27.440]                       muffled <- FALSE
[01:29:27.440]                       if (inherits(cond, "message")) {
[01:29:27.440]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.440]                         if (muffled) 
[01:29:27.440]                           invokeRestart("muffleMessage")
[01:29:27.440]                       }
[01:29:27.440]                       else if (inherits(cond, "warning")) {
[01:29:27.440]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.440]                         if (muffled) 
[01:29:27.440]                           invokeRestart("muffleWarning")
[01:29:27.440]                       }
[01:29:27.440]                       else if (inherits(cond, "condition")) {
[01:29:27.440]                         if (!is.null(pattern)) {
[01:29:27.440]                           computeRestarts <- base::computeRestarts
[01:29:27.440]                           grepl <- base::grepl
[01:29:27.440]                           restarts <- computeRestarts(cond)
[01:29:27.440]                           for (restart in restarts) {
[01:29:27.440]                             name <- restart$name
[01:29:27.440]                             if (is.null(name)) 
[01:29:27.440]                               next
[01:29:27.440]                             if (!grepl(pattern, name)) 
[01:29:27.440]                               next
[01:29:27.440]                             invokeRestart(restart)
[01:29:27.440]                             muffled <- TRUE
[01:29:27.440]                             break
[01:29:27.440]                           }
[01:29:27.440]                         }
[01:29:27.440]                       }
[01:29:27.440]                       invisible(muffled)
[01:29:27.440]                     }
[01:29:27.440]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.440]                   }
[01:29:27.440]                 }
[01:29:27.440]             }
[01:29:27.440]         }))
[01:29:27.440]     }, error = function(ex) {
[01:29:27.440]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.440]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.440]                 ...future.rng), started = ...future.startTime, 
[01:29:27.440]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.440]             version = "1.8"), class = "FutureResult")
[01:29:27.440]     }, finally = {
[01:29:27.440]         if (!identical(...future.workdir, getwd())) 
[01:29:27.440]             setwd(...future.workdir)
[01:29:27.440]         {
[01:29:27.440]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.440]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.440]             }
[01:29:27.440]             base::options(...future.oldOptions)
[01:29:27.440]             if (.Platform$OS.type == "windows") {
[01:29:27.440]                 old_names <- names(...future.oldEnvVars)
[01:29:27.440]                 envs <- base::Sys.getenv()
[01:29:27.440]                 names <- names(envs)
[01:29:27.440]                 common <- intersect(names, old_names)
[01:29:27.440]                 added <- setdiff(names, old_names)
[01:29:27.440]                 removed <- setdiff(old_names, names)
[01:29:27.440]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.440]                   envs[common]]
[01:29:27.440]                 NAMES <- toupper(changed)
[01:29:27.440]                 args <- list()
[01:29:27.440]                 for (kk in seq_along(NAMES)) {
[01:29:27.440]                   name <- changed[[kk]]
[01:29:27.440]                   NAME <- NAMES[[kk]]
[01:29:27.440]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.440]                     next
[01:29:27.440]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.440]                 }
[01:29:27.440]                 NAMES <- toupper(added)
[01:29:27.440]                 for (kk in seq_along(NAMES)) {
[01:29:27.440]                   name <- added[[kk]]
[01:29:27.440]                   NAME <- NAMES[[kk]]
[01:29:27.440]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.440]                     next
[01:29:27.440]                   args[[name]] <- ""
[01:29:27.440]                 }
[01:29:27.440]                 NAMES <- toupper(removed)
[01:29:27.440]                 for (kk in seq_along(NAMES)) {
[01:29:27.440]                   name <- removed[[kk]]
[01:29:27.440]                   NAME <- NAMES[[kk]]
[01:29:27.440]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.440]                     next
[01:29:27.440]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.440]                 }
[01:29:27.440]                 if (length(args) > 0) 
[01:29:27.440]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.440]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.440]             }
[01:29:27.440]             else {
[01:29:27.440]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.440]             }
[01:29:27.440]             {
[01:29:27.440]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.440]                   0L) {
[01:29:27.440]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.440]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.440]                   base::options(opts)
[01:29:27.440]                 }
[01:29:27.440]                 {
[01:29:27.440]                   {
[01:29:27.440]                     base::assign(".Random.seed", c(10407L, -2113589453L, 
[01:29:27.440]                     -328779341L, 32665513L, -540026874L, 111718912L, 
[01:29:27.440]                     -414573498L), envir = base::globalenv(), 
[01:29:27.440]                       inherits = FALSE)
[01:29:27.440]                     NULL
[01:29:27.440]                   }
[01:29:27.440]                   options(future.plan = NULL)
[01:29:27.440]                   if (is.na(NA_character_)) 
[01:29:27.440]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.440]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.440]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.440]                   {
[01:29:27.440]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.440]                     if (!future$lazy) 
[01:29:27.440]                       future <- run(future)
[01:29:27.440]                     invisible(future)
[01:29:27.440]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.440]                 }
[01:29:27.440]             }
[01:29:27.440]         }
[01:29:27.440]     })
[01:29:27.440]     if (TRUE) {
[01:29:27.440]         base::sink(type = "output", split = FALSE)
[01:29:27.440]         if (TRUE) {
[01:29:27.440]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.440]         }
[01:29:27.440]         else {
[01:29:27.440]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.440]         }
[01:29:27.440]         base::close(...future.stdout)
[01:29:27.440]         ...future.stdout <- NULL
[01:29:27.440]     }
[01:29:27.440]     ...future.result$conditions <- ...future.conditions
[01:29:27.440]     ...future.result$finished <- base::Sys.time()
[01:29:27.440]     ...future.result
[01:29:27.440] }
[01:29:27.444] assign_globals() ...
[01:29:27.444] List of 1
[01:29:27.444]  $ x: int [1:4] 0 1 2 3
[01:29:27.444]  - attr(*, "where")=List of 1
[01:29:27.444]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.444]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.444]  - attr(*, "resolved")= logi FALSE
[01:29:27.444]  - attr(*, "total_size")= num 64
[01:29:27.444]  - attr(*, "already-done")= logi TRUE
[01:29:27.447] - copied 'x' to environment
[01:29:27.448] assign_globals() ... done
[01:29:27.448] plan(): Setting new future strategy stack:
[01:29:27.448] List of future strategies:
[01:29:27.448] 1. sequential:
[01:29:27.448]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.448]    - tweaked: FALSE
[01:29:27.448]    - call: NULL
[01:29:27.449] plan(): nbrOfWorkers() = 1
[01:29:27.450] plan(): Setting new future strategy stack:
[01:29:27.450] List of future strategies:
[01:29:27.450] 1. sequential:
[01:29:27.450]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.450]    - tweaked: FALSE
[01:29:27.450]    - call: plan(strategy)
[01:29:27.451] plan(): nbrOfWorkers() = 1
[01:29:27.451] SequentialFuture started (and completed)
[01:29:27.451] - Launch lazy future ... done
[01:29:27.452] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_3-924329'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96be7df10
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.453] getGlobalsAndPackages() ...
[01:29:27.453] Searching for globals...
[01:29:27.454] - globals found: [3] '{', 'sample', 'x'
[01:29:27.454] Searching for globals ... DONE
[01:29:27.454] Resolving globals: FALSE
[01:29:27.455] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.455] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.456] - globals: [1] 'x'
[01:29:27.456] 
[01:29:27.456] getGlobalsAndPackages() ... DONE
[01:29:27.456] run() for 'Future' ...
[01:29:27.457] - state: 'created'
[01:29:27.457] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.457] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.457] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.457]   - Field: 'label'
[01:29:27.458]   - Field: 'local'
[01:29:27.458]   - Field: 'owner'
[01:29:27.458]   - Field: 'envir'
[01:29:27.458]   - Field: 'packages'
[01:29:27.458]   - Field: 'gc'
[01:29:27.459]   - Field: 'conditions'
[01:29:27.459]   - Field: 'expr'
[01:29:27.459]   - Field: 'uuid'
[01:29:27.459]   - Field: 'seed'
[01:29:27.459]   - Field: 'version'
[01:29:27.459]   - Field: 'result'
[01:29:27.460]   - Field: 'asynchronous'
[01:29:27.460]   - Field: 'calls'
[01:29:27.460]   - Field: 'globals'
[01:29:27.460]   - Field: 'stdout'
[01:29:27.460]   - Field: 'earlySignal'
[01:29:27.460]   - Field: 'lazy'
[01:29:27.461]   - Field: 'state'
[01:29:27.461] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.461] - Launch lazy future ...
[01:29:27.461] Packages needed by the future expression (n = 0): <none>
[01:29:27.461] Packages needed by future strategies (n = 0): <none>
[01:29:27.462] {
[01:29:27.462]     {
[01:29:27.462]         {
[01:29:27.462]             ...future.startTime <- base::Sys.time()
[01:29:27.462]             {
[01:29:27.462]                 {
[01:29:27.462]                   {
[01:29:27.462]                     base::local({
[01:29:27.462]                       has_future <- base::requireNamespace("future", 
[01:29:27.462]                         quietly = TRUE)
[01:29:27.462]                       if (has_future) {
[01:29:27.462]                         ns <- base::getNamespace("future")
[01:29:27.462]                         version <- ns[[".package"]][["version"]]
[01:29:27.462]                         if (is.null(version)) 
[01:29:27.462]                           version <- utils::packageVersion("future")
[01:29:27.462]                       }
[01:29:27.462]                       else {
[01:29:27.462]                         version <- NULL
[01:29:27.462]                       }
[01:29:27.462]                       if (!has_future || version < "1.8.0") {
[01:29:27.462]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.462]                           "", base::R.version$version.string), 
[01:29:27.462]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.462]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.462]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.462]                             "release", "version")], collapse = " "), 
[01:29:27.462]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.462]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.462]                           info)
[01:29:27.462]                         info <- base::paste(info, collapse = "; ")
[01:29:27.462]                         if (!has_future) {
[01:29:27.462]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.462]                             info)
[01:29:27.462]                         }
[01:29:27.462]                         else {
[01:29:27.462]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.462]                             info, version)
[01:29:27.462]                         }
[01:29:27.462]                         base::stop(msg)
[01:29:27.462]                       }
[01:29:27.462]                     })
[01:29:27.462]                   }
[01:29:27.462]                   options(future.plan = NULL)
[01:29:27.462]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.462]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.462]                 }
[01:29:27.462]                 ...future.workdir <- getwd()
[01:29:27.462]             }
[01:29:27.462]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.462]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.462]         }
[01:29:27.462]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.462]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.462]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.462]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.462]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.462]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.462]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.462]             base::names(...future.oldOptions))
[01:29:27.462]     }
[01:29:27.462]     if (FALSE) {
[01:29:27.462]     }
[01:29:27.462]     else {
[01:29:27.462]         if (TRUE) {
[01:29:27.462]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.462]                 open = "w")
[01:29:27.462]         }
[01:29:27.462]         else {
[01:29:27.462]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.462]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.462]         }
[01:29:27.462]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.462]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.462]             base::sink(type = "output", split = FALSE)
[01:29:27.462]             base::close(...future.stdout)
[01:29:27.462]         }, add = TRUE)
[01:29:27.462]     }
[01:29:27.462]     ...future.frame <- base::sys.nframe()
[01:29:27.462]     ...future.conditions <- base::list()
[01:29:27.462]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.462]     if (FALSE) {
[01:29:27.462]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.462]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.462]     }
[01:29:27.462]     ...future.result <- base::tryCatch({
[01:29:27.462]         base::withCallingHandlers({
[01:29:27.462]             ...future.value <- base::withVisible(base::local({
[01:29:27.462]                 sample(x, size = 1L)
[01:29:27.462]             }))
[01:29:27.462]             future::FutureResult(value = ...future.value$value, 
[01:29:27.462]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.462]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.462]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.462]                     ...future.globalenv.names))
[01:29:27.462]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.462]         }, condition = base::local({
[01:29:27.462]             c <- base::c
[01:29:27.462]             inherits <- base::inherits
[01:29:27.462]             invokeRestart <- base::invokeRestart
[01:29:27.462]             length <- base::length
[01:29:27.462]             list <- base::list
[01:29:27.462]             seq.int <- base::seq.int
[01:29:27.462]             signalCondition <- base::signalCondition
[01:29:27.462]             sys.calls <- base::sys.calls
[01:29:27.462]             `[[` <- base::`[[`
[01:29:27.462]             `+` <- base::`+`
[01:29:27.462]             `<<-` <- base::`<<-`
[01:29:27.462]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.462]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.462]                   3L)]
[01:29:27.462]             }
[01:29:27.462]             function(cond) {
[01:29:27.462]                 is_error <- inherits(cond, "error")
[01:29:27.462]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.462]                   NULL)
[01:29:27.462]                 if (is_error) {
[01:29:27.462]                   sessionInformation <- function() {
[01:29:27.462]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.462]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.462]                       search = base::search(), system = base::Sys.info())
[01:29:27.462]                   }
[01:29:27.462]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.462]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.462]                     cond$call), session = sessionInformation(), 
[01:29:27.462]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.462]                   signalCondition(cond)
[01:29:27.462]                 }
[01:29:27.462]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.462]                 "immediateCondition"))) {
[01:29:27.462]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.462]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.462]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.462]                   if (TRUE && !signal) {
[01:29:27.462]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.462]                     {
[01:29:27.462]                       inherits <- base::inherits
[01:29:27.462]                       invokeRestart <- base::invokeRestart
[01:29:27.462]                       is.null <- base::is.null
[01:29:27.462]                       muffled <- FALSE
[01:29:27.462]                       if (inherits(cond, "message")) {
[01:29:27.462]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.462]                         if (muffled) 
[01:29:27.462]                           invokeRestart("muffleMessage")
[01:29:27.462]                       }
[01:29:27.462]                       else if (inherits(cond, "warning")) {
[01:29:27.462]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.462]                         if (muffled) 
[01:29:27.462]                           invokeRestart("muffleWarning")
[01:29:27.462]                       }
[01:29:27.462]                       else if (inherits(cond, "condition")) {
[01:29:27.462]                         if (!is.null(pattern)) {
[01:29:27.462]                           computeRestarts <- base::computeRestarts
[01:29:27.462]                           grepl <- base::grepl
[01:29:27.462]                           restarts <- computeRestarts(cond)
[01:29:27.462]                           for (restart in restarts) {
[01:29:27.462]                             name <- restart$name
[01:29:27.462]                             if (is.null(name)) 
[01:29:27.462]                               next
[01:29:27.462]                             if (!grepl(pattern, name)) 
[01:29:27.462]                               next
[01:29:27.462]                             invokeRestart(restart)
[01:29:27.462]                             muffled <- TRUE
[01:29:27.462]                             break
[01:29:27.462]                           }
[01:29:27.462]                         }
[01:29:27.462]                       }
[01:29:27.462]                       invisible(muffled)
[01:29:27.462]                     }
[01:29:27.462]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.462]                   }
[01:29:27.462]                 }
[01:29:27.462]                 else {
[01:29:27.462]                   if (TRUE) {
[01:29:27.462]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.462]                     {
[01:29:27.462]                       inherits <- base::inherits
[01:29:27.462]                       invokeRestart <- base::invokeRestart
[01:29:27.462]                       is.null <- base::is.null
[01:29:27.462]                       muffled <- FALSE
[01:29:27.462]                       if (inherits(cond, "message")) {
[01:29:27.462]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.462]                         if (muffled) 
[01:29:27.462]                           invokeRestart("muffleMessage")
[01:29:27.462]                       }
[01:29:27.462]                       else if (inherits(cond, "warning")) {
[01:29:27.462]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.462]                         if (muffled) 
[01:29:27.462]                           invokeRestart("muffleWarning")
[01:29:27.462]                       }
[01:29:27.462]                       else if (inherits(cond, "condition")) {
[01:29:27.462]                         if (!is.null(pattern)) {
[01:29:27.462]                           computeRestarts <- base::computeRestarts
[01:29:27.462]                           grepl <- base::grepl
[01:29:27.462]                           restarts <- computeRestarts(cond)
[01:29:27.462]                           for (restart in restarts) {
[01:29:27.462]                             name <- restart$name
[01:29:27.462]                             if (is.null(name)) 
[01:29:27.462]                               next
[01:29:27.462]                             if (!grepl(pattern, name)) 
[01:29:27.462]                               next
[01:29:27.462]                             invokeRestart(restart)
[01:29:27.462]                             muffled <- TRUE
[01:29:27.462]                             break
[01:29:27.462]                           }
[01:29:27.462]                         }
[01:29:27.462]                       }
[01:29:27.462]                       invisible(muffled)
[01:29:27.462]                     }
[01:29:27.462]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.462]                   }
[01:29:27.462]                 }
[01:29:27.462]             }
[01:29:27.462]         }))
[01:29:27.462]     }, error = function(ex) {
[01:29:27.462]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.462]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.462]                 ...future.rng), started = ...future.startTime, 
[01:29:27.462]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.462]             version = "1.8"), class = "FutureResult")
[01:29:27.462]     }, finally = {
[01:29:27.462]         if (!identical(...future.workdir, getwd())) 
[01:29:27.462]             setwd(...future.workdir)
[01:29:27.462]         {
[01:29:27.462]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.462]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.462]             }
[01:29:27.462]             base::options(...future.oldOptions)
[01:29:27.462]             if (.Platform$OS.type == "windows") {
[01:29:27.462]                 old_names <- names(...future.oldEnvVars)
[01:29:27.462]                 envs <- base::Sys.getenv()
[01:29:27.462]                 names <- names(envs)
[01:29:27.462]                 common <- intersect(names, old_names)
[01:29:27.462]                 added <- setdiff(names, old_names)
[01:29:27.462]                 removed <- setdiff(old_names, names)
[01:29:27.462]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.462]                   envs[common]]
[01:29:27.462]                 NAMES <- toupper(changed)
[01:29:27.462]                 args <- list()
[01:29:27.462]                 for (kk in seq_along(NAMES)) {
[01:29:27.462]                   name <- changed[[kk]]
[01:29:27.462]                   NAME <- NAMES[[kk]]
[01:29:27.462]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.462]                     next
[01:29:27.462]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.462]                 }
[01:29:27.462]                 NAMES <- toupper(added)
[01:29:27.462]                 for (kk in seq_along(NAMES)) {
[01:29:27.462]                   name <- added[[kk]]
[01:29:27.462]                   NAME <- NAMES[[kk]]
[01:29:27.462]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.462]                     next
[01:29:27.462]                   args[[name]] <- ""
[01:29:27.462]                 }
[01:29:27.462]                 NAMES <- toupper(removed)
[01:29:27.462]                 for (kk in seq_along(NAMES)) {
[01:29:27.462]                   name <- removed[[kk]]
[01:29:27.462]                   NAME <- NAMES[[kk]]
[01:29:27.462]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.462]                     next
[01:29:27.462]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.462]                 }
[01:29:27.462]                 if (length(args) > 0) 
[01:29:27.462]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.462]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.462]             }
[01:29:27.462]             else {
[01:29:27.462]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.462]             }
[01:29:27.462]             {
[01:29:27.462]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.462]                   0L) {
[01:29:27.462]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.462]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.462]                   base::options(opts)
[01:29:27.462]                 }
[01:29:27.462]                 {
[01:29:27.462]                   {
[01:29:27.462]                     base::assign(".Random.seed", c(10407L, 32665513L, 
[01:29:27.462]                     771380658L, 382824604L, -414573498L, -284229981L, 
[01:29:27.462]                     951522791L), envir = base::globalenv(), inherits = FALSE)
[01:29:27.462]                     NULL
[01:29:27.462]                   }
[01:29:27.462]                   options(future.plan = NULL)
[01:29:27.462]                   if (is.na(NA_character_)) 
[01:29:27.462]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.462]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.462]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.462]                   {
[01:29:27.462]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.462]                     if (!future$lazy) 
[01:29:27.462]                       future <- run(future)
[01:29:27.462]                     invisible(future)
[01:29:27.462]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.462]                 }
[01:29:27.462]             }
[01:29:27.462]         }
[01:29:27.462]     })
[01:29:27.462]     if (TRUE) {
[01:29:27.462]         base::sink(type = "output", split = FALSE)
[01:29:27.462]         if (TRUE) {
[01:29:27.462]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.462]         }
[01:29:27.462]         else {
[01:29:27.462]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.462]         }
[01:29:27.462]         base::close(...future.stdout)
[01:29:27.462]         ...future.stdout <- NULL
[01:29:27.462]     }
[01:29:27.462]     ...future.result$conditions <- ...future.conditions
[01:29:27.462]     ...future.result$finished <- base::Sys.time()
[01:29:27.462]     ...future.result
[01:29:27.462] }
[01:29:27.466] assign_globals() ...
[01:29:27.466] List of 1
[01:29:27.466]  $ x: int [1:4] 0 1 2 3
[01:29:27.466]  - attr(*, "where")=List of 1
[01:29:27.466]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.466]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.466]  - attr(*, "resolved")= logi FALSE
[01:29:27.466]  - attr(*, "total_size")= num 64
[01:29:27.466]  - attr(*, "already-done")= logi TRUE
[01:29:27.469] - copied 'x' to environment
[01:29:27.469] assign_globals() ... done
[01:29:27.469] plan(): Setting new future strategy stack:
[01:29:27.470] List of future strategies:
[01:29:27.470] 1. sequential:
[01:29:27.470]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.470]    - tweaked: FALSE
[01:29:27.470]    - call: NULL
[01:29:27.470] plan(): nbrOfWorkers() = 1
[01:29:27.472] plan(): Setting new future strategy stack:
[01:29:27.472] List of future strategies:
[01:29:27.472] 1. sequential:
[01:29:27.472]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.472]    - tweaked: FALSE
[01:29:27.472]    - call: plan(strategy)
[01:29:27.472] plan(): nbrOfWorkers() = 1
[01:29:27.473] SequentialFuture started (and completed)
[01:29:27.473] - Launch lazy future ... done
[01:29:27.473] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_4-777755'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96be7df10
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.474] resolve() on list ...
[01:29:27.474]  recursive: 0
[01:29:27.474]  length: 4
[01:29:27.475] 
[01:29:27.475] resolved() for 'SequentialFuture' ...
[01:29:27.475] - state: 'finished'
[01:29:27.475] - run: TRUE
[01:29:27.475] - result: 'FutureResult'
[01:29:27.475] resolved() for 'SequentialFuture' ... done
[01:29:27.476] Future #1
[01:29:27.476] signalConditionsASAP(SequentialFuture, pos=1) ...
[01:29:27.476] - nx: 4
[01:29:27.476] - relay: TRUE
[01:29:27.476] - stdout: TRUE
[01:29:27.477] - signal: TRUE
[01:29:27.477] - resignal: FALSE
[01:29:27.477] - force: TRUE
[01:29:27.477] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:27.477] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:27.479]  - until=1
[01:29:27.479]  - relaying element #1
[01:29:27.479] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:27.479] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:27.479] signalConditionsASAP(SequentialFuture, pos=1) ... done
[01:29:27.480]  length: 3 (resolved future 1)
[01:29:27.480] resolved() for 'SequentialFuture' ...
[01:29:27.480] - state: 'finished'
[01:29:27.480] - run: TRUE
[01:29:27.480] - result: 'FutureResult'
[01:29:27.480] resolved() for 'SequentialFuture' ... done
[01:29:27.481] Future #2
[01:29:27.481] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:29:27.481] - nx: 4
[01:29:27.481] - relay: TRUE
[01:29:27.481] - stdout: TRUE
[01:29:27.482] - signal: TRUE
[01:29:27.482] - resignal: FALSE
[01:29:27.482] - force: TRUE
[01:29:27.482] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:27.482] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:27.482]  - until=2
[01:29:27.482]  - relaying element #2
[01:29:27.483] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:27.483] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:27.483] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:29:27.483]  length: 2 (resolved future 2)
[01:29:27.483] resolved() for 'SequentialFuture' ...
[01:29:27.484] - state: 'finished'
[01:29:27.484] - run: TRUE
[01:29:27.484] - result: 'FutureResult'
[01:29:27.484] resolved() for 'SequentialFuture' ... done
[01:29:27.484] Future #3
[01:29:27.485] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:29:27.485] - nx: 4
[01:29:27.485] - relay: TRUE
[01:29:27.485] - stdout: TRUE
[01:29:27.485] - signal: TRUE
[01:29:27.485] - resignal: FALSE
[01:29:27.485] - force: TRUE
[01:29:27.486] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:27.486] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:27.486]  - until=3
[01:29:27.486]  - relaying element #3
[01:29:27.486] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:27.487] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:27.487] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:29:27.487]  length: 1 (resolved future 3)
[01:29:27.487] resolved() for 'SequentialFuture' ...
[01:29:27.487] - state: 'finished'
[01:29:27.487] - run: TRUE
[01:29:27.488] - result: 'FutureResult'
[01:29:27.488] resolved() for 'SequentialFuture' ... done
[01:29:27.488] Future #4
[01:29:27.488] signalConditionsASAP(SequentialFuture, pos=4) ...
[01:29:27.488] - nx: 4
[01:29:27.489] - relay: TRUE
[01:29:27.489] - stdout: TRUE
[01:29:27.489] - signal: TRUE
[01:29:27.489] - resignal: FALSE
[01:29:27.489] - force: TRUE
[01:29:27.489] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:27.489] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:27.490]  - until=4
[01:29:27.490]  - relaying element #4
[01:29:27.490] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.490] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.490] signalConditionsASAP(SequentialFuture, pos=4) ... done
[01:29:27.491]  length: 0 (resolved future 4)
[01:29:27.491] Relaying remaining futures
[01:29:27.491] signalConditionsASAP(NULL, pos=0) ...
[01:29:27.491] - nx: 4
[01:29:27.491] - relay: TRUE
[01:29:27.491] - stdout: TRUE
[01:29:27.491] - signal: TRUE
[01:29:27.492] - resignal: FALSE
[01:29:27.492] - force: TRUE
[01:29:27.492] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.492] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[01:29:27.492] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.492] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.493] signalConditionsASAP(NULL, pos=0) ... done
[01:29:27.493] resolve() on list ... DONE
[[1]]
[1] 0

[[2]]
[1] 2

[[3]]
[1] 3

[[4]]
[1] 3

[01:29:27.493] getGlobalsAndPackages() ...
[01:29:27.494] Searching for globals...
[01:29:27.495] - globals found: [3] '{', 'sample', 'x'
[01:29:27.495] Searching for globals ... DONE
[01:29:27.495] Resolving globals: FALSE
[01:29:27.496] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.496] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.496] - globals: [1] 'x'
[01:29:27.496] 
[01:29:27.497] getGlobalsAndPackages() ... DONE
[01:29:27.497] run() for 'Future' ...
[01:29:27.497] - state: 'created'
[01:29:27.497] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.498] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.498] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.498]   - Field: 'label'
[01:29:27.498]   - Field: 'local'
[01:29:27.498]   - Field: 'owner'
[01:29:27.499]   - Field: 'envir'
[01:29:27.499]   - Field: 'packages'
[01:29:27.499]   - Field: 'gc'
[01:29:27.499]   - Field: 'conditions'
[01:29:27.499]   - Field: 'expr'
[01:29:27.499]   - Field: 'uuid'
[01:29:27.500]   - Field: 'seed'
[01:29:27.500]   - Field: 'version'
[01:29:27.500]   - Field: 'result'
[01:29:27.500]   - Field: 'asynchronous'
[01:29:27.500]   - Field: 'calls'
[01:29:27.500]   - Field: 'globals'
[01:29:27.501]   - Field: 'stdout'
[01:29:27.501]   - Field: 'earlySignal'
[01:29:27.501]   - Field: 'lazy'
[01:29:27.501]   - Field: 'state'
[01:29:27.501] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.501] - Launch lazy future ...
[01:29:27.502] Packages needed by the future expression (n = 0): <none>
[01:29:27.502] Packages needed by future strategies (n = 0): <none>
[01:29:27.503] {
[01:29:27.503]     {
[01:29:27.503]         {
[01:29:27.503]             ...future.startTime <- base::Sys.time()
[01:29:27.503]             {
[01:29:27.503]                 {
[01:29:27.503]                   {
[01:29:27.503]                     base::local({
[01:29:27.503]                       has_future <- base::requireNamespace("future", 
[01:29:27.503]                         quietly = TRUE)
[01:29:27.503]                       if (has_future) {
[01:29:27.503]                         ns <- base::getNamespace("future")
[01:29:27.503]                         version <- ns[[".package"]][["version"]]
[01:29:27.503]                         if (is.null(version)) 
[01:29:27.503]                           version <- utils::packageVersion("future")
[01:29:27.503]                       }
[01:29:27.503]                       else {
[01:29:27.503]                         version <- NULL
[01:29:27.503]                       }
[01:29:27.503]                       if (!has_future || version < "1.8.0") {
[01:29:27.503]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.503]                           "", base::R.version$version.string), 
[01:29:27.503]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.503]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.503]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.503]                             "release", "version")], collapse = " "), 
[01:29:27.503]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.503]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.503]                           info)
[01:29:27.503]                         info <- base::paste(info, collapse = "; ")
[01:29:27.503]                         if (!has_future) {
[01:29:27.503]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.503]                             info)
[01:29:27.503]                         }
[01:29:27.503]                         else {
[01:29:27.503]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.503]                             info, version)
[01:29:27.503]                         }
[01:29:27.503]                         base::stop(msg)
[01:29:27.503]                       }
[01:29:27.503]                     })
[01:29:27.503]                   }
[01:29:27.503]                   options(future.plan = NULL)
[01:29:27.503]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.503]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.503]                 }
[01:29:27.503]                 ...future.workdir <- getwd()
[01:29:27.503]             }
[01:29:27.503]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.503]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.503]         }
[01:29:27.503]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.503]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.503]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.503]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.503]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.503]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.503]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.503]             base::names(...future.oldOptions))
[01:29:27.503]     }
[01:29:27.503]     if (FALSE) {
[01:29:27.503]     }
[01:29:27.503]     else {
[01:29:27.503]         if (TRUE) {
[01:29:27.503]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.503]                 open = "w")
[01:29:27.503]         }
[01:29:27.503]         else {
[01:29:27.503]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.503]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.503]         }
[01:29:27.503]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.503]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.503]             base::sink(type = "output", split = FALSE)
[01:29:27.503]             base::close(...future.stdout)
[01:29:27.503]         }, add = TRUE)
[01:29:27.503]     }
[01:29:27.503]     ...future.frame <- base::sys.nframe()
[01:29:27.503]     ...future.conditions <- base::list()
[01:29:27.503]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.503]     if (FALSE) {
[01:29:27.503]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.503]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.503]     }
[01:29:27.503]     ...future.result <- base::tryCatch({
[01:29:27.503]         base::withCallingHandlers({
[01:29:27.503]             ...future.value <- base::withVisible(base::local({
[01:29:27.503]                 sample(x, size = 1L)
[01:29:27.503]             }))
[01:29:27.503]             future::FutureResult(value = ...future.value$value, 
[01:29:27.503]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.503]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.503]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.503]                     ...future.globalenv.names))
[01:29:27.503]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.503]         }, condition = base::local({
[01:29:27.503]             c <- base::c
[01:29:27.503]             inherits <- base::inherits
[01:29:27.503]             invokeRestart <- base::invokeRestart
[01:29:27.503]             length <- base::length
[01:29:27.503]             list <- base::list
[01:29:27.503]             seq.int <- base::seq.int
[01:29:27.503]             signalCondition <- base::signalCondition
[01:29:27.503]             sys.calls <- base::sys.calls
[01:29:27.503]             `[[` <- base::`[[`
[01:29:27.503]             `+` <- base::`+`
[01:29:27.503]             `<<-` <- base::`<<-`
[01:29:27.503]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.503]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.503]                   3L)]
[01:29:27.503]             }
[01:29:27.503]             function(cond) {
[01:29:27.503]                 is_error <- inherits(cond, "error")
[01:29:27.503]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.503]                   NULL)
[01:29:27.503]                 if (is_error) {
[01:29:27.503]                   sessionInformation <- function() {
[01:29:27.503]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.503]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.503]                       search = base::search(), system = base::Sys.info())
[01:29:27.503]                   }
[01:29:27.503]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.503]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.503]                     cond$call), session = sessionInformation(), 
[01:29:27.503]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.503]                   signalCondition(cond)
[01:29:27.503]                 }
[01:29:27.503]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.503]                 "immediateCondition"))) {
[01:29:27.503]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.503]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.503]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.503]                   if (TRUE && !signal) {
[01:29:27.503]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.503]                     {
[01:29:27.503]                       inherits <- base::inherits
[01:29:27.503]                       invokeRestart <- base::invokeRestart
[01:29:27.503]                       is.null <- base::is.null
[01:29:27.503]                       muffled <- FALSE
[01:29:27.503]                       if (inherits(cond, "message")) {
[01:29:27.503]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.503]                         if (muffled) 
[01:29:27.503]                           invokeRestart("muffleMessage")
[01:29:27.503]                       }
[01:29:27.503]                       else if (inherits(cond, "warning")) {
[01:29:27.503]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.503]                         if (muffled) 
[01:29:27.503]                           invokeRestart("muffleWarning")
[01:29:27.503]                       }
[01:29:27.503]                       else if (inherits(cond, "condition")) {
[01:29:27.503]                         if (!is.null(pattern)) {
[01:29:27.503]                           computeRestarts <- base::computeRestarts
[01:29:27.503]                           grepl <- base::grepl
[01:29:27.503]                           restarts <- computeRestarts(cond)
[01:29:27.503]                           for (restart in restarts) {
[01:29:27.503]                             name <- restart$name
[01:29:27.503]                             if (is.null(name)) 
[01:29:27.503]                               next
[01:29:27.503]                             if (!grepl(pattern, name)) 
[01:29:27.503]                               next
[01:29:27.503]                             invokeRestart(restart)
[01:29:27.503]                             muffled <- TRUE
[01:29:27.503]                             break
[01:29:27.503]                           }
[01:29:27.503]                         }
[01:29:27.503]                       }
[01:29:27.503]                       invisible(muffled)
[01:29:27.503]                     }
[01:29:27.503]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.503]                   }
[01:29:27.503]                 }
[01:29:27.503]                 else {
[01:29:27.503]                   if (TRUE) {
[01:29:27.503]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.503]                     {
[01:29:27.503]                       inherits <- base::inherits
[01:29:27.503]                       invokeRestart <- base::invokeRestart
[01:29:27.503]                       is.null <- base::is.null
[01:29:27.503]                       muffled <- FALSE
[01:29:27.503]                       if (inherits(cond, "message")) {
[01:29:27.503]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.503]                         if (muffled) 
[01:29:27.503]                           invokeRestart("muffleMessage")
[01:29:27.503]                       }
[01:29:27.503]                       else if (inherits(cond, "warning")) {
[01:29:27.503]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.503]                         if (muffled) 
[01:29:27.503]                           invokeRestart("muffleWarning")
[01:29:27.503]                       }
[01:29:27.503]                       else if (inherits(cond, "condition")) {
[01:29:27.503]                         if (!is.null(pattern)) {
[01:29:27.503]                           computeRestarts <- base::computeRestarts
[01:29:27.503]                           grepl <- base::grepl
[01:29:27.503]                           restarts <- computeRestarts(cond)
[01:29:27.503]                           for (restart in restarts) {
[01:29:27.503]                             name <- restart$name
[01:29:27.503]                             if (is.null(name)) 
[01:29:27.503]                               next
[01:29:27.503]                             if (!grepl(pattern, name)) 
[01:29:27.503]                               next
[01:29:27.503]                             invokeRestart(restart)
[01:29:27.503]                             muffled <- TRUE
[01:29:27.503]                             break
[01:29:27.503]                           }
[01:29:27.503]                         }
[01:29:27.503]                       }
[01:29:27.503]                       invisible(muffled)
[01:29:27.503]                     }
[01:29:27.503]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.503]                   }
[01:29:27.503]                 }
[01:29:27.503]             }
[01:29:27.503]         }))
[01:29:27.503]     }, error = function(ex) {
[01:29:27.503]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.503]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.503]                 ...future.rng), started = ...future.startTime, 
[01:29:27.503]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.503]             version = "1.8"), class = "FutureResult")
[01:29:27.503]     }, finally = {
[01:29:27.503]         if (!identical(...future.workdir, getwd())) 
[01:29:27.503]             setwd(...future.workdir)
[01:29:27.503]         {
[01:29:27.503]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.503]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.503]             }
[01:29:27.503]             base::options(...future.oldOptions)
[01:29:27.503]             if (.Platform$OS.type == "windows") {
[01:29:27.503]                 old_names <- names(...future.oldEnvVars)
[01:29:27.503]                 envs <- base::Sys.getenv()
[01:29:27.503]                 names <- names(envs)
[01:29:27.503]                 common <- intersect(names, old_names)
[01:29:27.503]                 added <- setdiff(names, old_names)
[01:29:27.503]                 removed <- setdiff(old_names, names)
[01:29:27.503]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.503]                   envs[common]]
[01:29:27.503]                 NAMES <- toupper(changed)
[01:29:27.503]                 args <- list()
[01:29:27.503]                 for (kk in seq_along(NAMES)) {
[01:29:27.503]                   name <- changed[[kk]]
[01:29:27.503]                   NAME <- NAMES[[kk]]
[01:29:27.503]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.503]                     next
[01:29:27.503]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.503]                 }
[01:29:27.503]                 NAMES <- toupper(added)
[01:29:27.503]                 for (kk in seq_along(NAMES)) {
[01:29:27.503]                   name <- added[[kk]]
[01:29:27.503]                   NAME <- NAMES[[kk]]
[01:29:27.503]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.503]                     next
[01:29:27.503]                   args[[name]] <- ""
[01:29:27.503]                 }
[01:29:27.503]                 NAMES <- toupper(removed)
[01:29:27.503]                 for (kk in seq_along(NAMES)) {
[01:29:27.503]                   name <- removed[[kk]]
[01:29:27.503]                   NAME <- NAMES[[kk]]
[01:29:27.503]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.503]                     next
[01:29:27.503]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.503]                 }
[01:29:27.503]                 if (length(args) > 0) 
[01:29:27.503]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.503]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.503]             }
[01:29:27.503]             else {
[01:29:27.503]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.503]             }
[01:29:27.503]             {
[01:29:27.503]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.503]                   0L) {
[01:29:27.503]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.503]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.503]                   base::options(opts)
[01:29:27.503]                 }
[01:29:27.503]                 {
[01:29:27.503]                   {
[01:29:27.503]                     base::assign(".Random.seed", c(10407L, 1788803019L, 
[01:29:27.503]                     -2062194282L, 1512492668L, 1863688414L, -1553839187L, 
[01:29:27.503]                     -1952535076L), envir = base::globalenv(), 
[01:29:27.503]                       inherits = FALSE)
[01:29:27.503]                     NULL
[01:29:27.503]                   }
[01:29:27.503]                   options(future.plan = NULL)
[01:29:27.503]                   if (is.na(NA_character_)) 
[01:29:27.503]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.503]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.503]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.503]                   {
[01:29:27.503]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.503]                     if (!future$lazy) 
[01:29:27.503]                       future <- run(future)
[01:29:27.503]                     invisible(future)
[01:29:27.503]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.503]                 }
[01:29:27.503]             }
[01:29:27.503]         }
[01:29:27.503]     })
[01:29:27.503]     if (TRUE) {
[01:29:27.503]         base::sink(type = "output", split = FALSE)
[01:29:27.503]         if (TRUE) {
[01:29:27.503]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.503]         }
[01:29:27.503]         else {
[01:29:27.503]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.503]         }
[01:29:27.503]         base::close(...future.stdout)
[01:29:27.503]         ...future.stdout <- NULL
[01:29:27.503]     }
[01:29:27.503]     ...future.result$conditions <- ...future.conditions
[01:29:27.503]     ...future.result$finished <- base::Sys.time()
[01:29:27.503]     ...future.result
[01:29:27.503] }
[01:29:27.506] assign_globals() ...
[01:29:27.506] List of 1
[01:29:27.506]  $ x: int [1:4] 0 1 2 3
[01:29:27.506]  - attr(*, "where")=List of 1
[01:29:27.506]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.506]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.506]  - attr(*, "resolved")= logi FALSE
[01:29:27.506]  - attr(*, "total_size")= num 64
[01:29:27.506]  - attr(*, "already-done")= logi TRUE
[01:29:27.509] - copied 'x' to environment
[01:29:27.510] assign_globals() ... done
[01:29:27.510] plan(): Setting new future strategy stack:
[01:29:27.510] List of future strategies:
[01:29:27.510] 1. sequential:
[01:29:27.510]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.510]    - tweaked: FALSE
[01:29:27.510]    - call: NULL
[01:29:27.511] plan(): nbrOfWorkers() = 1
[01:29:27.512] plan(): Setting new future strategy stack:
[01:29:27.512] List of future strategies:
[01:29:27.512] 1. sequential:
[01:29:27.512]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.512]    - tweaked: FALSE
[01:29:27.512]    - call: plan(strategy)
[01:29:27.514] plan(): nbrOfWorkers() = 1
[01:29:27.514] SequentialFuture started (and completed)
[01:29:27.514] - Launch lazy future ... done
[01:29:27.514] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_1-249481'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96abdc4c8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.515] getGlobalsAndPackages() ...
[01:29:27.516] Searching for globals...
[01:29:27.517] - globals found: [3] '{', 'sample', 'x'
[01:29:27.517] Searching for globals ... DONE
[01:29:27.517] Resolving globals: FALSE
[01:29:27.518] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.518] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.518] - globals: [1] 'x'
[01:29:27.519] 
[01:29:27.519] getGlobalsAndPackages() ... DONE
[01:29:27.519] run() for 'Future' ...
[01:29:27.519] - state: 'created'
[01:29:27.519] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.520] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.520] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.520]   - Field: 'label'
[01:29:27.520]   - Field: 'local'
[01:29:27.520]   - Field: 'owner'
[01:29:27.521]   - Field: 'envir'
[01:29:27.521]   - Field: 'packages'
[01:29:27.521]   - Field: 'gc'
[01:29:27.521]   - Field: 'conditions'
[01:29:27.521]   - Field: 'expr'
[01:29:27.522]   - Field: 'uuid'
[01:29:27.522]   - Field: 'seed'
[01:29:27.522]   - Field: 'version'
[01:29:27.522]   - Field: 'result'
[01:29:27.522]   - Field: 'asynchronous'
[01:29:27.522]   - Field: 'calls'
[01:29:27.523]   - Field: 'globals'
[01:29:27.523]   - Field: 'stdout'
[01:29:27.523]   - Field: 'earlySignal'
[01:29:27.523]   - Field: 'lazy'
[01:29:27.523]   - Field: 'state'
[01:29:27.523] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.524] - Launch lazy future ...
[01:29:27.524] Packages needed by the future expression (n = 0): <none>
[01:29:27.524] Packages needed by future strategies (n = 0): <none>
[01:29:27.525] {
[01:29:27.525]     {
[01:29:27.525]         {
[01:29:27.525]             ...future.startTime <- base::Sys.time()
[01:29:27.525]             {
[01:29:27.525]                 {
[01:29:27.525]                   {
[01:29:27.525]                     base::local({
[01:29:27.525]                       has_future <- base::requireNamespace("future", 
[01:29:27.525]                         quietly = TRUE)
[01:29:27.525]                       if (has_future) {
[01:29:27.525]                         ns <- base::getNamespace("future")
[01:29:27.525]                         version <- ns[[".package"]][["version"]]
[01:29:27.525]                         if (is.null(version)) 
[01:29:27.525]                           version <- utils::packageVersion("future")
[01:29:27.525]                       }
[01:29:27.525]                       else {
[01:29:27.525]                         version <- NULL
[01:29:27.525]                       }
[01:29:27.525]                       if (!has_future || version < "1.8.0") {
[01:29:27.525]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.525]                           "", base::R.version$version.string), 
[01:29:27.525]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.525]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.525]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.525]                             "release", "version")], collapse = " "), 
[01:29:27.525]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.525]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.525]                           info)
[01:29:27.525]                         info <- base::paste(info, collapse = "; ")
[01:29:27.525]                         if (!has_future) {
[01:29:27.525]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.525]                             info)
[01:29:27.525]                         }
[01:29:27.525]                         else {
[01:29:27.525]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.525]                             info, version)
[01:29:27.525]                         }
[01:29:27.525]                         base::stop(msg)
[01:29:27.525]                       }
[01:29:27.525]                     })
[01:29:27.525]                   }
[01:29:27.525]                   options(future.plan = NULL)
[01:29:27.525]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.525]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.525]                 }
[01:29:27.525]                 ...future.workdir <- getwd()
[01:29:27.525]             }
[01:29:27.525]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.525]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.525]         }
[01:29:27.525]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.525]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.525]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.525]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.525]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.525]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.525]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.525]             base::names(...future.oldOptions))
[01:29:27.525]     }
[01:29:27.525]     if (FALSE) {
[01:29:27.525]     }
[01:29:27.525]     else {
[01:29:27.525]         if (TRUE) {
[01:29:27.525]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.525]                 open = "w")
[01:29:27.525]         }
[01:29:27.525]         else {
[01:29:27.525]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.525]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.525]         }
[01:29:27.525]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.525]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.525]             base::sink(type = "output", split = FALSE)
[01:29:27.525]             base::close(...future.stdout)
[01:29:27.525]         }, add = TRUE)
[01:29:27.525]     }
[01:29:27.525]     ...future.frame <- base::sys.nframe()
[01:29:27.525]     ...future.conditions <- base::list()
[01:29:27.525]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.525]     if (FALSE) {
[01:29:27.525]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.525]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.525]     }
[01:29:27.525]     ...future.result <- base::tryCatch({
[01:29:27.525]         base::withCallingHandlers({
[01:29:27.525]             ...future.value <- base::withVisible(base::local({
[01:29:27.525]                 sample(x, size = 1L)
[01:29:27.525]             }))
[01:29:27.525]             future::FutureResult(value = ...future.value$value, 
[01:29:27.525]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.525]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.525]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.525]                     ...future.globalenv.names))
[01:29:27.525]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.525]         }, condition = base::local({
[01:29:27.525]             c <- base::c
[01:29:27.525]             inherits <- base::inherits
[01:29:27.525]             invokeRestart <- base::invokeRestart
[01:29:27.525]             length <- base::length
[01:29:27.525]             list <- base::list
[01:29:27.525]             seq.int <- base::seq.int
[01:29:27.525]             signalCondition <- base::signalCondition
[01:29:27.525]             sys.calls <- base::sys.calls
[01:29:27.525]             `[[` <- base::`[[`
[01:29:27.525]             `+` <- base::`+`
[01:29:27.525]             `<<-` <- base::`<<-`
[01:29:27.525]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.525]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.525]                   3L)]
[01:29:27.525]             }
[01:29:27.525]             function(cond) {
[01:29:27.525]                 is_error <- inherits(cond, "error")
[01:29:27.525]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.525]                   NULL)
[01:29:27.525]                 if (is_error) {
[01:29:27.525]                   sessionInformation <- function() {
[01:29:27.525]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.525]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.525]                       search = base::search(), system = base::Sys.info())
[01:29:27.525]                   }
[01:29:27.525]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.525]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.525]                     cond$call), session = sessionInformation(), 
[01:29:27.525]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.525]                   signalCondition(cond)
[01:29:27.525]                 }
[01:29:27.525]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.525]                 "immediateCondition"))) {
[01:29:27.525]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.525]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.525]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.525]                   if (TRUE && !signal) {
[01:29:27.525]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.525]                     {
[01:29:27.525]                       inherits <- base::inherits
[01:29:27.525]                       invokeRestart <- base::invokeRestart
[01:29:27.525]                       is.null <- base::is.null
[01:29:27.525]                       muffled <- FALSE
[01:29:27.525]                       if (inherits(cond, "message")) {
[01:29:27.525]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.525]                         if (muffled) 
[01:29:27.525]                           invokeRestart("muffleMessage")
[01:29:27.525]                       }
[01:29:27.525]                       else if (inherits(cond, "warning")) {
[01:29:27.525]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.525]                         if (muffled) 
[01:29:27.525]                           invokeRestart("muffleWarning")
[01:29:27.525]                       }
[01:29:27.525]                       else if (inherits(cond, "condition")) {
[01:29:27.525]                         if (!is.null(pattern)) {
[01:29:27.525]                           computeRestarts <- base::computeRestarts
[01:29:27.525]                           grepl <- base::grepl
[01:29:27.525]                           restarts <- computeRestarts(cond)
[01:29:27.525]                           for (restart in restarts) {
[01:29:27.525]                             name <- restart$name
[01:29:27.525]                             if (is.null(name)) 
[01:29:27.525]                               next
[01:29:27.525]                             if (!grepl(pattern, name)) 
[01:29:27.525]                               next
[01:29:27.525]                             invokeRestart(restart)
[01:29:27.525]                             muffled <- TRUE
[01:29:27.525]                             break
[01:29:27.525]                           }
[01:29:27.525]                         }
[01:29:27.525]                       }
[01:29:27.525]                       invisible(muffled)
[01:29:27.525]                     }
[01:29:27.525]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.525]                   }
[01:29:27.525]                 }
[01:29:27.525]                 else {
[01:29:27.525]                   if (TRUE) {
[01:29:27.525]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.525]                     {
[01:29:27.525]                       inherits <- base::inherits
[01:29:27.525]                       invokeRestart <- base::invokeRestart
[01:29:27.525]                       is.null <- base::is.null
[01:29:27.525]                       muffled <- FALSE
[01:29:27.525]                       if (inherits(cond, "message")) {
[01:29:27.525]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.525]                         if (muffled) 
[01:29:27.525]                           invokeRestart("muffleMessage")
[01:29:27.525]                       }
[01:29:27.525]                       else if (inherits(cond, "warning")) {
[01:29:27.525]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.525]                         if (muffled) 
[01:29:27.525]                           invokeRestart("muffleWarning")
[01:29:27.525]                       }
[01:29:27.525]                       else if (inherits(cond, "condition")) {
[01:29:27.525]                         if (!is.null(pattern)) {
[01:29:27.525]                           computeRestarts <- base::computeRestarts
[01:29:27.525]                           grepl <- base::grepl
[01:29:27.525]                           restarts <- computeRestarts(cond)
[01:29:27.525]                           for (restart in restarts) {
[01:29:27.525]                             name <- restart$name
[01:29:27.525]                             if (is.null(name)) 
[01:29:27.525]                               next
[01:29:27.525]                             if (!grepl(pattern, name)) 
[01:29:27.525]                               next
[01:29:27.525]                             invokeRestart(restart)
[01:29:27.525]                             muffled <- TRUE
[01:29:27.525]                             break
[01:29:27.525]                           }
[01:29:27.525]                         }
[01:29:27.525]                       }
[01:29:27.525]                       invisible(muffled)
[01:29:27.525]                     }
[01:29:27.525]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.525]                   }
[01:29:27.525]                 }
[01:29:27.525]             }
[01:29:27.525]         }))
[01:29:27.525]     }, error = function(ex) {
[01:29:27.525]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.525]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.525]                 ...future.rng), started = ...future.startTime, 
[01:29:27.525]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.525]             version = "1.8"), class = "FutureResult")
[01:29:27.525]     }, finally = {
[01:29:27.525]         if (!identical(...future.workdir, getwd())) 
[01:29:27.525]             setwd(...future.workdir)
[01:29:27.525]         {
[01:29:27.525]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.525]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.525]             }
[01:29:27.525]             base::options(...future.oldOptions)
[01:29:27.525]             if (.Platform$OS.type == "windows") {
[01:29:27.525]                 old_names <- names(...future.oldEnvVars)
[01:29:27.525]                 envs <- base::Sys.getenv()
[01:29:27.525]                 names <- names(envs)
[01:29:27.525]                 common <- intersect(names, old_names)
[01:29:27.525]                 added <- setdiff(names, old_names)
[01:29:27.525]                 removed <- setdiff(old_names, names)
[01:29:27.525]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.525]                   envs[common]]
[01:29:27.525]                 NAMES <- toupper(changed)
[01:29:27.525]                 args <- list()
[01:29:27.525]                 for (kk in seq_along(NAMES)) {
[01:29:27.525]                   name <- changed[[kk]]
[01:29:27.525]                   NAME <- NAMES[[kk]]
[01:29:27.525]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.525]                     next
[01:29:27.525]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.525]                 }
[01:29:27.525]                 NAMES <- toupper(added)
[01:29:27.525]                 for (kk in seq_along(NAMES)) {
[01:29:27.525]                   name <- added[[kk]]
[01:29:27.525]                   NAME <- NAMES[[kk]]
[01:29:27.525]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.525]                     next
[01:29:27.525]                   args[[name]] <- ""
[01:29:27.525]                 }
[01:29:27.525]                 NAMES <- toupper(removed)
[01:29:27.525]                 for (kk in seq_along(NAMES)) {
[01:29:27.525]                   name <- removed[[kk]]
[01:29:27.525]                   NAME <- NAMES[[kk]]
[01:29:27.525]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.525]                     next
[01:29:27.525]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.525]                 }
[01:29:27.525]                 if (length(args) > 0) 
[01:29:27.525]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.525]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.525]             }
[01:29:27.525]             else {
[01:29:27.525]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.525]             }
[01:29:27.525]             {
[01:29:27.525]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.525]                   0L) {
[01:29:27.525]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.525]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.525]                   base::options(opts)
[01:29:27.525]                 }
[01:29:27.525]                 {
[01:29:27.525]                   {
[01:29:27.525]                     base::assign(".Random.seed", c(10407L, 1512492668L, 
[01:29:27.525]                     -1424970269L, -874615779L, -1952535076L, 
[01:29:27.525]                     -2035996805L, -360807571L), envir = base::globalenv(), 
[01:29:27.525]                       inherits = FALSE)
[01:29:27.525]                     NULL
[01:29:27.525]                   }
[01:29:27.525]                   options(future.plan = NULL)
[01:29:27.525]                   if (is.na(NA_character_)) 
[01:29:27.525]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.525]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.525]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.525]                   {
[01:29:27.525]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.525]                     if (!future$lazy) 
[01:29:27.525]                       future <- run(future)
[01:29:27.525]                     invisible(future)
[01:29:27.525]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.525]                 }
[01:29:27.525]             }
[01:29:27.525]         }
[01:29:27.525]     })
[01:29:27.525]     if (TRUE) {
[01:29:27.525]         base::sink(type = "output", split = FALSE)
[01:29:27.525]         if (TRUE) {
[01:29:27.525]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.525]         }
[01:29:27.525]         else {
[01:29:27.525]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.525]         }
[01:29:27.525]         base::close(...future.stdout)
[01:29:27.525]         ...future.stdout <- NULL
[01:29:27.525]     }
[01:29:27.525]     ...future.result$conditions <- ...future.conditions
[01:29:27.525]     ...future.result$finished <- base::Sys.time()
[01:29:27.525]     ...future.result
[01:29:27.525] }
[01:29:27.528] assign_globals() ...
[01:29:27.528] List of 1
[01:29:27.528]  $ x: int [1:4] 0 1 2 3
[01:29:27.528]  - attr(*, "where")=List of 1
[01:29:27.528]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.528]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.528]  - attr(*, "resolved")= logi FALSE
[01:29:27.528]  - attr(*, "total_size")= num 64
[01:29:27.528]  - attr(*, "already-done")= logi TRUE
[01:29:27.531] - copied 'x' to environment
[01:29:27.532] assign_globals() ... done
[01:29:27.532] plan(): Setting new future strategy stack:
[01:29:27.532] List of future strategies:
[01:29:27.532] 1. sequential:
[01:29:27.532]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.532]    - tweaked: FALSE
[01:29:27.532]    - call: NULL
[01:29:27.533] plan(): nbrOfWorkers() = 1
[01:29:27.534] plan(): Setting new future strategy stack:
[01:29:27.534] List of future strategies:
[01:29:27.534] 1. sequential:
[01:29:27.534]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.534]    - tweaked: FALSE
[01:29:27.534]    - call: plan(strategy)
[01:29:27.535] plan(): nbrOfWorkers() = 1
[01:29:27.535] SequentialFuture started (and completed)
[01:29:27.535] - Launch lazy future ... done
[01:29:27.535] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_2-778592'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96abdc4c8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.536] getGlobalsAndPackages() ...
[01:29:27.537] Searching for globals...
[01:29:27.538] - globals found: [3] '{', 'sample', 'x'
[01:29:27.538] Searching for globals ... DONE
[01:29:27.538] Resolving globals: FALSE
[01:29:27.539] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.539] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.539] - globals: [1] 'x'
[01:29:27.539] 
[01:29:27.539] getGlobalsAndPackages() ... DONE
[01:29:27.540] run() for 'Future' ...
[01:29:27.540] - state: 'created'
[01:29:27.540] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.541] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.541] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.541]   - Field: 'label'
[01:29:27.541]   - Field: 'local'
[01:29:27.541]   - Field: 'owner'
[01:29:27.541]   - Field: 'envir'
[01:29:27.542]   - Field: 'packages'
[01:29:27.542]   - Field: 'gc'
[01:29:27.542]   - Field: 'conditions'
[01:29:27.542]   - Field: 'expr'
[01:29:27.542]   - Field: 'uuid'
[01:29:27.543]   - Field: 'seed'
[01:29:27.543]   - Field: 'version'
[01:29:27.543]   - Field: 'result'
[01:29:27.543]   - Field: 'asynchronous'
[01:29:27.543]   - Field: 'calls'
[01:29:27.543]   - Field: 'globals'
[01:29:27.544]   - Field: 'stdout'
[01:29:27.544]   - Field: 'earlySignal'
[01:29:27.544]   - Field: 'lazy'
[01:29:27.544]   - Field: 'state'
[01:29:27.544] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.544] - Launch lazy future ...
[01:29:27.545] Packages needed by the future expression (n = 0): <none>
[01:29:27.545] Packages needed by future strategies (n = 0): <none>
[01:29:27.545] {
[01:29:27.545]     {
[01:29:27.545]         {
[01:29:27.545]             ...future.startTime <- base::Sys.time()
[01:29:27.545]             {
[01:29:27.545]                 {
[01:29:27.545]                   {
[01:29:27.545]                     base::local({
[01:29:27.545]                       has_future <- base::requireNamespace("future", 
[01:29:27.545]                         quietly = TRUE)
[01:29:27.545]                       if (has_future) {
[01:29:27.545]                         ns <- base::getNamespace("future")
[01:29:27.545]                         version <- ns[[".package"]][["version"]]
[01:29:27.545]                         if (is.null(version)) 
[01:29:27.545]                           version <- utils::packageVersion("future")
[01:29:27.545]                       }
[01:29:27.545]                       else {
[01:29:27.545]                         version <- NULL
[01:29:27.545]                       }
[01:29:27.545]                       if (!has_future || version < "1.8.0") {
[01:29:27.545]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.545]                           "", base::R.version$version.string), 
[01:29:27.545]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.545]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.545]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.545]                             "release", "version")], collapse = " "), 
[01:29:27.545]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.545]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.545]                           info)
[01:29:27.545]                         info <- base::paste(info, collapse = "; ")
[01:29:27.545]                         if (!has_future) {
[01:29:27.545]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.545]                             info)
[01:29:27.545]                         }
[01:29:27.545]                         else {
[01:29:27.545]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.545]                             info, version)
[01:29:27.545]                         }
[01:29:27.545]                         base::stop(msg)
[01:29:27.545]                       }
[01:29:27.545]                     })
[01:29:27.545]                   }
[01:29:27.545]                   options(future.plan = NULL)
[01:29:27.545]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.545]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.545]                 }
[01:29:27.545]                 ...future.workdir <- getwd()
[01:29:27.545]             }
[01:29:27.545]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.545]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.545]         }
[01:29:27.545]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.545]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.545]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.545]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.545]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.545]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.545]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.545]             base::names(...future.oldOptions))
[01:29:27.545]     }
[01:29:27.545]     if (FALSE) {
[01:29:27.545]     }
[01:29:27.545]     else {
[01:29:27.545]         if (TRUE) {
[01:29:27.545]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.545]                 open = "w")
[01:29:27.545]         }
[01:29:27.545]         else {
[01:29:27.545]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.545]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.545]         }
[01:29:27.545]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.545]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.545]             base::sink(type = "output", split = FALSE)
[01:29:27.545]             base::close(...future.stdout)
[01:29:27.545]         }, add = TRUE)
[01:29:27.545]     }
[01:29:27.545]     ...future.frame <- base::sys.nframe()
[01:29:27.545]     ...future.conditions <- base::list()
[01:29:27.545]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.545]     if (FALSE) {
[01:29:27.545]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.545]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.545]     }
[01:29:27.545]     ...future.result <- base::tryCatch({
[01:29:27.545]         base::withCallingHandlers({
[01:29:27.545]             ...future.value <- base::withVisible(base::local({
[01:29:27.545]                 sample(x, size = 1L)
[01:29:27.545]             }))
[01:29:27.545]             future::FutureResult(value = ...future.value$value, 
[01:29:27.545]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.545]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.545]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.545]                     ...future.globalenv.names))
[01:29:27.545]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.545]         }, condition = base::local({
[01:29:27.545]             c <- base::c
[01:29:27.545]             inherits <- base::inherits
[01:29:27.545]             invokeRestart <- base::invokeRestart
[01:29:27.545]             length <- base::length
[01:29:27.545]             list <- base::list
[01:29:27.545]             seq.int <- base::seq.int
[01:29:27.545]             signalCondition <- base::signalCondition
[01:29:27.545]             sys.calls <- base::sys.calls
[01:29:27.545]             `[[` <- base::`[[`
[01:29:27.545]             `+` <- base::`+`
[01:29:27.545]             `<<-` <- base::`<<-`
[01:29:27.545]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.545]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.545]                   3L)]
[01:29:27.545]             }
[01:29:27.545]             function(cond) {
[01:29:27.545]                 is_error <- inherits(cond, "error")
[01:29:27.545]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.545]                   NULL)
[01:29:27.545]                 if (is_error) {
[01:29:27.545]                   sessionInformation <- function() {
[01:29:27.545]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.545]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.545]                       search = base::search(), system = base::Sys.info())
[01:29:27.545]                   }
[01:29:27.545]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.545]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.545]                     cond$call), session = sessionInformation(), 
[01:29:27.545]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.545]                   signalCondition(cond)
[01:29:27.545]                 }
[01:29:27.545]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.545]                 "immediateCondition"))) {
[01:29:27.545]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.545]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.545]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.545]                   if (TRUE && !signal) {
[01:29:27.545]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.545]                     {
[01:29:27.545]                       inherits <- base::inherits
[01:29:27.545]                       invokeRestart <- base::invokeRestart
[01:29:27.545]                       is.null <- base::is.null
[01:29:27.545]                       muffled <- FALSE
[01:29:27.545]                       if (inherits(cond, "message")) {
[01:29:27.545]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.545]                         if (muffled) 
[01:29:27.545]                           invokeRestart("muffleMessage")
[01:29:27.545]                       }
[01:29:27.545]                       else if (inherits(cond, "warning")) {
[01:29:27.545]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.545]                         if (muffled) 
[01:29:27.545]                           invokeRestart("muffleWarning")
[01:29:27.545]                       }
[01:29:27.545]                       else if (inherits(cond, "condition")) {
[01:29:27.545]                         if (!is.null(pattern)) {
[01:29:27.545]                           computeRestarts <- base::computeRestarts
[01:29:27.545]                           grepl <- base::grepl
[01:29:27.545]                           restarts <- computeRestarts(cond)
[01:29:27.545]                           for (restart in restarts) {
[01:29:27.545]                             name <- restart$name
[01:29:27.545]                             if (is.null(name)) 
[01:29:27.545]                               next
[01:29:27.545]                             if (!grepl(pattern, name)) 
[01:29:27.545]                               next
[01:29:27.545]                             invokeRestart(restart)
[01:29:27.545]                             muffled <- TRUE
[01:29:27.545]                             break
[01:29:27.545]                           }
[01:29:27.545]                         }
[01:29:27.545]                       }
[01:29:27.545]                       invisible(muffled)
[01:29:27.545]                     }
[01:29:27.545]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.545]                   }
[01:29:27.545]                 }
[01:29:27.545]                 else {
[01:29:27.545]                   if (TRUE) {
[01:29:27.545]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.545]                     {
[01:29:27.545]                       inherits <- base::inherits
[01:29:27.545]                       invokeRestart <- base::invokeRestart
[01:29:27.545]                       is.null <- base::is.null
[01:29:27.545]                       muffled <- FALSE
[01:29:27.545]                       if (inherits(cond, "message")) {
[01:29:27.545]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.545]                         if (muffled) 
[01:29:27.545]                           invokeRestart("muffleMessage")
[01:29:27.545]                       }
[01:29:27.545]                       else if (inherits(cond, "warning")) {
[01:29:27.545]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.545]                         if (muffled) 
[01:29:27.545]                           invokeRestart("muffleWarning")
[01:29:27.545]                       }
[01:29:27.545]                       else if (inherits(cond, "condition")) {
[01:29:27.545]                         if (!is.null(pattern)) {
[01:29:27.545]                           computeRestarts <- base::computeRestarts
[01:29:27.545]                           grepl <- base::grepl
[01:29:27.545]                           restarts <- computeRestarts(cond)
[01:29:27.545]                           for (restart in restarts) {
[01:29:27.545]                             name <- restart$name
[01:29:27.545]                             if (is.null(name)) 
[01:29:27.545]                               next
[01:29:27.545]                             if (!grepl(pattern, name)) 
[01:29:27.545]                               next
[01:29:27.545]                             invokeRestart(restart)
[01:29:27.545]                             muffled <- TRUE
[01:29:27.545]                             break
[01:29:27.545]                           }
[01:29:27.545]                         }
[01:29:27.545]                       }
[01:29:27.545]                       invisible(muffled)
[01:29:27.545]                     }
[01:29:27.545]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.545]                   }
[01:29:27.545]                 }
[01:29:27.545]             }
[01:29:27.545]         }))
[01:29:27.545]     }, error = function(ex) {
[01:29:27.545]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.545]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.545]                 ...future.rng), started = ...future.startTime, 
[01:29:27.545]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.545]             version = "1.8"), class = "FutureResult")
[01:29:27.545]     }, finally = {
[01:29:27.545]         if (!identical(...future.workdir, getwd())) 
[01:29:27.545]             setwd(...future.workdir)
[01:29:27.545]         {
[01:29:27.545]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.545]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.545]             }
[01:29:27.545]             base::options(...future.oldOptions)
[01:29:27.545]             if (.Platform$OS.type == "windows") {
[01:29:27.545]                 old_names <- names(...future.oldEnvVars)
[01:29:27.545]                 envs <- base::Sys.getenv()
[01:29:27.545]                 names <- names(envs)
[01:29:27.545]                 common <- intersect(names, old_names)
[01:29:27.545]                 added <- setdiff(names, old_names)
[01:29:27.545]                 removed <- setdiff(old_names, names)
[01:29:27.545]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.545]                   envs[common]]
[01:29:27.545]                 NAMES <- toupper(changed)
[01:29:27.545]                 args <- list()
[01:29:27.545]                 for (kk in seq_along(NAMES)) {
[01:29:27.545]                   name <- changed[[kk]]
[01:29:27.545]                   NAME <- NAMES[[kk]]
[01:29:27.545]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.545]                     next
[01:29:27.545]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.545]                 }
[01:29:27.545]                 NAMES <- toupper(added)
[01:29:27.545]                 for (kk in seq_along(NAMES)) {
[01:29:27.545]                   name <- added[[kk]]
[01:29:27.545]                   NAME <- NAMES[[kk]]
[01:29:27.545]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.545]                     next
[01:29:27.545]                   args[[name]] <- ""
[01:29:27.545]                 }
[01:29:27.545]                 NAMES <- toupper(removed)
[01:29:27.545]                 for (kk in seq_along(NAMES)) {
[01:29:27.545]                   name <- removed[[kk]]
[01:29:27.545]                   NAME <- NAMES[[kk]]
[01:29:27.545]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.545]                     next
[01:29:27.545]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.545]                 }
[01:29:27.545]                 if (length(args) > 0) 
[01:29:27.545]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.545]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.545]             }
[01:29:27.545]             else {
[01:29:27.545]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.545]             }
[01:29:27.545]             {
[01:29:27.545]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.545]                   0L) {
[01:29:27.545]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.545]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.545]                   base::options(opts)
[01:29:27.545]                 }
[01:29:27.545]                 {
[01:29:27.545]                   {
[01:29:27.545]                     base::assign(".Random.seed", c(10407L, -874615779L, 
[01:29:27.545]                     858954295L, 1745775247L, -360807571L, -322333159L, 
[01:29:27.545]                     1509109739L), envir = base::globalenv(), 
[01:29:27.545]                       inherits = FALSE)
[01:29:27.545]                     NULL
[01:29:27.545]                   }
[01:29:27.545]                   options(future.plan = NULL)
[01:29:27.545]                   if (is.na(NA_character_)) 
[01:29:27.545]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.545]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.545]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.545]                   {
[01:29:27.545]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.545]                     if (!future$lazy) 
[01:29:27.545]                       future <- run(future)
[01:29:27.545]                     invisible(future)
[01:29:27.545]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.545]                 }
[01:29:27.545]             }
[01:29:27.545]         }
[01:29:27.545]     })
[01:29:27.545]     if (TRUE) {
[01:29:27.545]         base::sink(type = "output", split = FALSE)
[01:29:27.545]         if (TRUE) {
[01:29:27.545]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.545]         }
[01:29:27.545]         else {
[01:29:27.545]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.545]         }
[01:29:27.545]         base::close(...future.stdout)
[01:29:27.545]         ...future.stdout <- NULL
[01:29:27.545]     }
[01:29:27.545]     ...future.result$conditions <- ...future.conditions
[01:29:27.545]     ...future.result$finished <- base::Sys.time()
[01:29:27.545]     ...future.result
[01:29:27.545] }
[01:29:27.549] assign_globals() ...
[01:29:27.550] List of 1
[01:29:27.550]  $ x: int [1:4] 0 1 2 3
[01:29:27.550]  - attr(*, "where")=List of 1
[01:29:27.550]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.550]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.550]  - attr(*, "resolved")= logi FALSE
[01:29:27.550]  - attr(*, "total_size")= num 64
[01:29:27.550]  - attr(*, "already-done")= logi TRUE
[01:29:27.554] - copied 'x' to environment
[01:29:27.554] assign_globals() ... done
[01:29:27.554] plan(): Setting new future strategy stack:
[01:29:27.555] List of future strategies:
[01:29:27.555] 1. sequential:
[01:29:27.555]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.555]    - tweaked: FALSE
[01:29:27.555]    - call: NULL
[01:29:27.555] plan(): nbrOfWorkers() = 1
[01:29:27.556] plan(): Setting new future strategy stack:
[01:29:27.557] List of future strategies:
[01:29:27.557] 1. sequential:
[01:29:27.557]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.557]    - tweaked: FALSE
[01:29:27.557]    - call: plan(strategy)
[01:29:27.557] plan(): nbrOfWorkers() = 1
[01:29:27.557] SequentialFuture started (and completed)
[01:29:27.558] - Launch lazy future ... done
[01:29:27.558] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_3-593436'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96abdc4c8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.559] getGlobalsAndPackages() ...
[01:29:27.559] Searching for globals...
[01:29:27.560] - globals found: [3] '{', 'sample', 'x'
[01:29:27.560] Searching for globals ... DONE
[01:29:27.561] Resolving globals: FALSE
[01:29:27.561] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.562] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.562] - globals: [1] 'x'
[01:29:27.562] 
[01:29:27.562] getGlobalsAndPackages() ... DONE
[01:29:27.562] run() for 'Future' ...
[01:29:27.563] - state: 'created'
[01:29:27.563] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.563] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.563] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.564]   - Field: 'label'
[01:29:27.564]   - Field: 'local'
[01:29:27.564]   - Field: 'owner'
[01:29:27.564]   - Field: 'envir'
[01:29:27.564]   - Field: 'packages'
[01:29:27.565]   - Field: 'gc'
[01:29:27.565]   - Field: 'conditions'
[01:29:27.565]   - Field: 'expr'
[01:29:27.566]   - Field: 'uuid'
[01:29:27.566]   - Field: 'seed'
[01:29:27.566]   - Field: 'version'
[01:29:27.566]   - Field: 'result'
[01:29:27.567]   - Field: 'asynchronous'
[01:29:27.567]   - Field: 'calls'
[01:29:27.567]   - Field: 'globals'
[01:29:27.567]   - Field: 'stdout'
[01:29:27.568]   - Field: 'earlySignal'
[01:29:27.568]   - Field: 'lazy'
[01:29:27.568]   - Field: 'state'
[01:29:27.569] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.569] - Launch lazy future ...
[01:29:27.569] Packages needed by the future expression (n = 0): <none>
[01:29:27.569] Packages needed by future strategies (n = 0): <none>
[01:29:27.570] {
[01:29:27.570]     {
[01:29:27.570]         {
[01:29:27.570]             ...future.startTime <- base::Sys.time()
[01:29:27.570]             {
[01:29:27.570]                 {
[01:29:27.570]                   {
[01:29:27.570]                     base::local({
[01:29:27.570]                       has_future <- base::requireNamespace("future", 
[01:29:27.570]                         quietly = TRUE)
[01:29:27.570]                       if (has_future) {
[01:29:27.570]                         ns <- base::getNamespace("future")
[01:29:27.570]                         version <- ns[[".package"]][["version"]]
[01:29:27.570]                         if (is.null(version)) 
[01:29:27.570]                           version <- utils::packageVersion("future")
[01:29:27.570]                       }
[01:29:27.570]                       else {
[01:29:27.570]                         version <- NULL
[01:29:27.570]                       }
[01:29:27.570]                       if (!has_future || version < "1.8.0") {
[01:29:27.570]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.570]                           "", base::R.version$version.string), 
[01:29:27.570]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.570]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.570]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.570]                             "release", "version")], collapse = " "), 
[01:29:27.570]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.570]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.570]                           info)
[01:29:27.570]                         info <- base::paste(info, collapse = "; ")
[01:29:27.570]                         if (!has_future) {
[01:29:27.570]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.570]                             info)
[01:29:27.570]                         }
[01:29:27.570]                         else {
[01:29:27.570]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.570]                             info, version)
[01:29:27.570]                         }
[01:29:27.570]                         base::stop(msg)
[01:29:27.570]                       }
[01:29:27.570]                     })
[01:29:27.570]                   }
[01:29:27.570]                   options(future.plan = NULL)
[01:29:27.570]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.570]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.570]                 }
[01:29:27.570]                 ...future.workdir <- getwd()
[01:29:27.570]             }
[01:29:27.570]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.570]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.570]         }
[01:29:27.570]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.570]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.570]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.570]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.570]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.570]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.570]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.570]             base::names(...future.oldOptions))
[01:29:27.570]     }
[01:29:27.570]     if (FALSE) {
[01:29:27.570]     }
[01:29:27.570]     else {
[01:29:27.570]         if (TRUE) {
[01:29:27.570]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.570]                 open = "w")
[01:29:27.570]         }
[01:29:27.570]         else {
[01:29:27.570]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.570]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.570]         }
[01:29:27.570]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.570]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.570]             base::sink(type = "output", split = FALSE)
[01:29:27.570]             base::close(...future.stdout)
[01:29:27.570]         }, add = TRUE)
[01:29:27.570]     }
[01:29:27.570]     ...future.frame <- base::sys.nframe()
[01:29:27.570]     ...future.conditions <- base::list()
[01:29:27.570]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.570]     if (FALSE) {
[01:29:27.570]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.570]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.570]     }
[01:29:27.570]     ...future.result <- base::tryCatch({
[01:29:27.570]         base::withCallingHandlers({
[01:29:27.570]             ...future.value <- base::withVisible(base::local({
[01:29:27.570]                 sample(x, size = 1L)
[01:29:27.570]             }))
[01:29:27.570]             future::FutureResult(value = ...future.value$value, 
[01:29:27.570]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.570]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.570]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.570]                     ...future.globalenv.names))
[01:29:27.570]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.570]         }, condition = base::local({
[01:29:27.570]             c <- base::c
[01:29:27.570]             inherits <- base::inherits
[01:29:27.570]             invokeRestart <- base::invokeRestart
[01:29:27.570]             length <- base::length
[01:29:27.570]             list <- base::list
[01:29:27.570]             seq.int <- base::seq.int
[01:29:27.570]             signalCondition <- base::signalCondition
[01:29:27.570]             sys.calls <- base::sys.calls
[01:29:27.570]             `[[` <- base::`[[`
[01:29:27.570]             `+` <- base::`+`
[01:29:27.570]             `<<-` <- base::`<<-`
[01:29:27.570]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.570]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.570]                   3L)]
[01:29:27.570]             }
[01:29:27.570]             function(cond) {
[01:29:27.570]                 is_error <- inherits(cond, "error")
[01:29:27.570]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.570]                   NULL)
[01:29:27.570]                 if (is_error) {
[01:29:27.570]                   sessionInformation <- function() {
[01:29:27.570]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.570]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.570]                       search = base::search(), system = base::Sys.info())
[01:29:27.570]                   }
[01:29:27.570]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.570]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.570]                     cond$call), session = sessionInformation(), 
[01:29:27.570]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.570]                   signalCondition(cond)
[01:29:27.570]                 }
[01:29:27.570]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.570]                 "immediateCondition"))) {
[01:29:27.570]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.570]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.570]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.570]                   if (TRUE && !signal) {
[01:29:27.570]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.570]                     {
[01:29:27.570]                       inherits <- base::inherits
[01:29:27.570]                       invokeRestart <- base::invokeRestart
[01:29:27.570]                       is.null <- base::is.null
[01:29:27.570]                       muffled <- FALSE
[01:29:27.570]                       if (inherits(cond, "message")) {
[01:29:27.570]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.570]                         if (muffled) 
[01:29:27.570]                           invokeRestart("muffleMessage")
[01:29:27.570]                       }
[01:29:27.570]                       else if (inherits(cond, "warning")) {
[01:29:27.570]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.570]                         if (muffled) 
[01:29:27.570]                           invokeRestart("muffleWarning")
[01:29:27.570]                       }
[01:29:27.570]                       else if (inherits(cond, "condition")) {
[01:29:27.570]                         if (!is.null(pattern)) {
[01:29:27.570]                           computeRestarts <- base::computeRestarts
[01:29:27.570]                           grepl <- base::grepl
[01:29:27.570]                           restarts <- computeRestarts(cond)
[01:29:27.570]                           for (restart in restarts) {
[01:29:27.570]                             name <- restart$name
[01:29:27.570]                             if (is.null(name)) 
[01:29:27.570]                               next
[01:29:27.570]                             if (!grepl(pattern, name)) 
[01:29:27.570]                               next
[01:29:27.570]                             invokeRestart(restart)
[01:29:27.570]                             muffled <- TRUE
[01:29:27.570]                             break
[01:29:27.570]                           }
[01:29:27.570]                         }
[01:29:27.570]                       }
[01:29:27.570]                       invisible(muffled)
[01:29:27.570]                     }
[01:29:27.570]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.570]                   }
[01:29:27.570]                 }
[01:29:27.570]                 else {
[01:29:27.570]                   if (TRUE) {
[01:29:27.570]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.570]                     {
[01:29:27.570]                       inherits <- base::inherits
[01:29:27.570]                       invokeRestart <- base::invokeRestart
[01:29:27.570]                       is.null <- base::is.null
[01:29:27.570]                       muffled <- FALSE
[01:29:27.570]                       if (inherits(cond, "message")) {
[01:29:27.570]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.570]                         if (muffled) 
[01:29:27.570]                           invokeRestart("muffleMessage")
[01:29:27.570]                       }
[01:29:27.570]                       else if (inherits(cond, "warning")) {
[01:29:27.570]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.570]                         if (muffled) 
[01:29:27.570]                           invokeRestart("muffleWarning")
[01:29:27.570]                       }
[01:29:27.570]                       else if (inherits(cond, "condition")) {
[01:29:27.570]                         if (!is.null(pattern)) {
[01:29:27.570]                           computeRestarts <- base::computeRestarts
[01:29:27.570]                           grepl <- base::grepl
[01:29:27.570]                           restarts <- computeRestarts(cond)
[01:29:27.570]                           for (restart in restarts) {
[01:29:27.570]                             name <- restart$name
[01:29:27.570]                             if (is.null(name)) 
[01:29:27.570]                               next
[01:29:27.570]                             if (!grepl(pattern, name)) 
[01:29:27.570]                               next
[01:29:27.570]                             invokeRestart(restart)
[01:29:27.570]                             muffled <- TRUE
[01:29:27.570]                             break
[01:29:27.570]                           }
[01:29:27.570]                         }
[01:29:27.570]                       }
[01:29:27.570]                       invisible(muffled)
[01:29:27.570]                     }
[01:29:27.570]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.570]                   }
[01:29:27.570]                 }
[01:29:27.570]             }
[01:29:27.570]         }))
[01:29:27.570]     }, error = function(ex) {
[01:29:27.570]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.570]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.570]                 ...future.rng), started = ...future.startTime, 
[01:29:27.570]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.570]             version = "1.8"), class = "FutureResult")
[01:29:27.570]     }, finally = {
[01:29:27.570]         if (!identical(...future.workdir, getwd())) 
[01:29:27.570]             setwd(...future.workdir)
[01:29:27.570]         {
[01:29:27.570]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.570]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.570]             }
[01:29:27.570]             base::options(...future.oldOptions)
[01:29:27.570]             if (.Platform$OS.type == "windows") {
[01:29:27.570]                 old_names <- names(...future.oldEnvVars)
[01:29:27.570]                 envs <- base::Sys.getenv()
[01:29:27.570]                 names <- names(envs)
[01:29:27.570]                 common <- intersect(names, old_names)
[01:29:27.570]                 added <- setdiff(names, old_names)
[01:29:27.570]                 removed <- setdiff(old_names, names)
[01:29:27.570]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.570]                   envs[common]]
[01:29:27.570]                 NAMES <- toupper(changed)
[01:29:27.570]                 args <- list()
[01:29:27.570]                 for (kk in seq_along(NAMES)) {
[01:29:27.570]                   name <- changed[[kk]]
[01:29:27.570]                   NAME <- NAMES[[kk]]
[01:29:27.570]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.570]                     next
[01:29:27.570]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.570]                 }
[01:29:27.570]                 NAMES <- toupper(added)
[01:29:27.570]                 for (kk in seq_along(NAMES)) {
[01:29:27.570]                   name <- added[[kk]]
[01:29:27.570]                   NAME <- NAMES[[kk]]
[01:29:27.570]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.570]                     next
[01:29:27.570]                   args[[name]] <- ""
[01:29:27.570]                 }
[01:29:27.570]                 NAMES <- toupper(removed)
[01:29:27.570]                 for (kk in seq_along(NAMES)) {
[01:29:27.570]                   name <- removed[[kk]]
[01:29:27.570]                   NAME <- NAMES[[kk]]
[01:29:27.570]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.570]                     next
[01:29:27.570]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.570]                 }
[01:29:27.570]                 if (length(args) > 0) 
[01:29:27.570]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.570]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.570]             }
[01:29:27.570]             else {
[01:29:27.570]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.570]             }
[01:29:27.570]             {
[01:29:27.570]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.570]                   0L) {
[01:29:27.570]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.570]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.570]                   base::options(opts)
[01:29:27.570]                 }
[01:29:27.570]                 {
[01:29:27.570]                   {
[01:29:27.570]                     base::assign(".Random.seed", c(10407L, 1745775247L, 
[01:29:27.570]                     -1336239575L, -260646334L, 1509109739L, -435616600L, 
[01:29:27.570]                     733352678L), envir = base::globalenv(), inherits = FALSE)
[01:29:27.570]                     NULL
[01:29:27.570]                   }
[01:29:27.570]                   options(future.plan = NULL)
[01:29:27.570]                   if (is.na(NA_character_)) 
[01:29:27.570]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.570]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.570]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.570]                   {
[01:29:27.570]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.570]                     if (!future$lazy) 
[01:29:27.570]                       future <- run(future)
[01:29:27.570]                     invisible(future)
[01:29:27.570]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.570]                 }
[01:29:27.570]             }
[01:29:27.570]         }
[01:29:27.570]     })
[01:29:27.570]     if (TRUE) {
[01:29:27.570]         base::sink(type = "output", split = FALSE)
[01:29:27.570]         if (TRUE) {
[01:29:27.570]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.570]         }
[01:29:27.570]         else {
[01:29:27.570]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.570]         }
[01:29:27.570]         base::close(...future.stdout)
[01:29:27.570]         ...future.stdout <- NULL
[01:29:27.570]     }
[01:29:27.570]     ...future.result$conditions <- ...future.conditions
[01:29:27.570]     ...future.result$finished <- base::Sys.time()
[01:29:27.570]     ...future.result
[01:29:27.570] }
[01:29:27.576] assign_globals() ...
[01:29:27.576] List of 1
[01:29:27.576]  $ x: int [1:4] 0 1 2 3
[01:29:27.576]  - attr(*, "where")=List of 1
[01:29:27.576]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.576]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.576]  - attr(*, "resolved")= logi FALSE
[01:29:27.576]  - attr(*, "total_size")= num 64
[01:29:27.576]  - attr(*, "already-done")= logi TRUE
[01:29:27.581] - copied 'x' to environment
[01:29:27.581] assign_globals() ... done
[01:29:27.582] plan(): Setting new future strategy stack:
[01:29:27.582] List of future strategies:
[01:29:27.582] 1. sequential:
[01:29:27.582]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.582]    - tweaked: FALSE
[01:29:27.582]    - call: NULL
[01:29:27.583] plan(): nbrOfWorkers() = 1
[01:29:27.585] plan(): Setting new future strategy stack:
[01:29:27.585] List of future strategies:
[01:29:27.585] 1. sequential:
[01:29:27.585]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.585]    - tweaked: FALSE
[01:29:27.585]    - call: plan(strategy)
[01:29:27.586] plan(): nbrOfWorkers() = 1
[01:29:27.586] SequentialFuture started (and completed)
[01:29:27.586] - Launch lazy future ... done
[01:29:27.587] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_4-115905'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96abdc4c8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.588] resolve() on list ...
[01:29:27.589]  recursive: 0
[01:29:27.589]  length: 4
[01:29:27.589] 
[01:29:27.589] resolved() for 'SequentialFuture' ...
[01:29:27.590] - state: 'finished'
[01:29:27.590] - run: TRUE
[01:29:27.590] - result: 'FutureResult'
[01:29:27.591] resolved() for 'SequentialFuture' ... done
[01:29:27.591] Future #1
[01:29:27.592] signalConditionsASAP(SequentialFuture, pos=1) ...
[01:29:27.592] - nx: 4
[01:29:27.592] - relay: TRUE
[01:29:27.592] - stdout: TRUE
[01:29:27.593] - signal: TRUE
[01:29:27.593] - resignal: FALSE
[01:29:27.593] - force: TRUE
[01:29:27.593] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:27.594] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:27.594]  - until=1
[01:29:27.594]  - relaying element #1
[01:29:27.599] signalConditions() ...
[01:29:27.599]  - include = 'immediateCondition'
[01:29:27.600]  - exclude = 
[01:29:27.600]  - resignal = FALSE
[01:29:27.601]  - Number of conditions: 1
[01:29:27.601] signalConditions() ... done
[01:29:27.602] signalConditions() ...
[01:29:27.603]  - include = 'immediateCondition'
[01:29:27.603]  - exclude = 
[01:29:27.604]  - resignal = FALSE
[01:29:27.604]  - Number of conditions: 1
[01:29:27.604] signalConditions() ... done
[01:29:27.605] signalConditions() ...
[01:29:27.605]  - include = 'condition'
[01:29:27.606]  - exclude = 'immediateCondition'
[01:29:27.606]  - resignal = TRUE
[01:29:27.607]  - Number of conditions: 1
[01:29:27.607]  - Condition #1: 'RngFutureError', 'FutureError', 'error', 'RngFutureCondition', 'FutureCondition', 'condition'
[01:29:27.608] signalConditions() ... done
[01:29:27.608] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:27.609] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:27.609] signalConditionsASAP(SequentialFuture, pos=1) ... done
<RngFutureError: UNRELIABLE VALUE: Future ('fsample_1-249481') unexpectedly generated random numbers without specifying argument 'seed'. There is a risk that those random numbers are not statistically sound and the overall results might be invalid. To fix this, specify 'seed=TRUE'. This ensures that proper, parallel-safe random numbers are produced via the L'Ecuyer-CMRG method. To disable this check, use 'seed=NULL', or set option 'future.rng.onMisuse' to "ignore".>


Future UUID: d5b23386-46ad-162c-b78e-7c0b0fdd5563


DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
SequentialFuture:
Label: 'fsample_1-249481'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96abdc4c8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Conditions captured: [n=1] 'RngFutureError'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'

DEBUG: END TROUBLESHOOTING HELP
[01:29:27.612] getGlobalsAndPackages() ...
[01:29:27.613] Searching for globals...
[01:29:27.616] - globals found: [3] '{', 'sample', 'x'
[01:29:27.617] Searching for globals ... DONE
[01:29:27.617] Resolving globals: FALSE
[01:29:27.618] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.619] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.619] - globals: [1] 'x'
[01:29:27.620] 
[01:29:27.620] getGlobalsAndPackages() ... DONE
[01:29:27.621] run() for 'Future' ...
[01:29:27.621] - state: 'created'
[01:29:27.622] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.623] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.623] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.624]   - Field: 'label'
[01:29:27.624]   - Field: 'local'
[01:29:27.624]   - Field: 'owner'
[01:29:27.625]   - Field: 'envir'
[01:29:27.625]   - Field: 'packages'
[01:29:27.625]   - Field: 'gc'
[01:29:27.626]   - Field: 'conditions'
[01:29:27.626]   - Field: 'expr'
[01:29:27.627]   - Field: 'uuid'
[01:29:27.627]   - Field: 'seed'
[01:29:27.627]   - Field: 'version'
[01:29:27.628]   - Field: 'result'
[01:29:27.628]   - Field: 'asynchronous'
[01:29:27.628]   - Field: 'calls'
[01:29:27.628]   - Field: 'globals'
[01:29:27.629]   - Field: 'stdout'
[01:29:27.629]   - Field: 'earlySignal'
[01:29:27.629]   - Field: 'lazy'
[01:29:27.629]   - Field: 'state'
[01:29:27.630] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.630] - Launch lazy future ...
[01:29:27.630] Packages needed by the future expression (n = 0): <none>
[01:29:27.631] Packages needed by future strategies (n = 0): <none>
[01:29:27.632] {
[01:29:27.632]     {
[01:29:27.632]         {
[01:29:27.632]             ...future.startTime <- base::Sys.time()
[01:29:27.632]             {
[01:29:27.632]                 {
[01:29:27.632]                   {
[01:29:27.632]                     base::local({
[01:29:27.632]                       has_future <- base::requireNamespace("future", 
[01:29:27.632]                         quietly = TRUE)
[01:29:27.632]                       if (has_future) {
[01:29:27.632]                         ns <- base::getNamespace("future")
[01:29:27.632]                         version <- ns[[".package"]][["version"]]
[01:29:27.632]                         if (is.null(version)) 
[01:29:27.632]                           version <- utils::packageVersion("future")
[01:29:27.632]                       }
[01:29:27.632]                       else {
[01:29:27.632]                         version <- NULL
[01:29:27.632]                       }
[01:29:27.632]                       if (!has_future || version < "1.8.0") {
[01:29:27.632]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.632]                           "", base::R.version$version.string), 
[01:29:27.632]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.632]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.632]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.632]                             "release", "version")], collapse = " "), 
[01:29:27.632]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.632]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.632]                           info)
[01:29:27.632]                         info <- base::paste(info, collapse = "; ")
[01:29:27.632]                         if (!has_future) {
[01:29:27.632]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.632]                             info)
[01:29:27.632]                         }
[01:29:27.632]                         else {
[01:29:27.632]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.632]                             info, version)
[01:29:27.632]                         }
[01:29:27.632]                         base::stop(msg)
[01:29:27.632]                       }
[01:29:27.632]                     })
[01:29:27.632]                   }
[01:29:27.632]                   options(future.plan = NULL)
[01:29:27.632]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.632]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.632]                 }
[01:29:27.632]                 ...future.workdir <- getwd()
[01:29:27.632]             }
[01:29:27.632]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.632]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.632]         }
[01:29:27.632]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.632]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.632]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.632]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.632]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.632]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.632]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.632]             base::names(...future.oldOptions))
[01:29:27.632]     }
[01:29:27.632]     if (FALSE) {
[01:29:27.632]     }
[01:29:27.632]     else {
[01:29:27.632]         if (TRUE) {
[01:29:27.632]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.632]                 open = "w")
[01:29:27.632]         }
[01:29:27.632]         else {
[01:29:27.632]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.632]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.632]         }
[01:29:27.632]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.632]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.632]             base::sink(type = "output", split = FALSE)
[01:29:27.632]             base::close(...future.stdout)
[01:29:27.632]         }, add = TRUE)
[01:29:27.632]     }
[01:29:27.632]     ...future.frame <- base::sys.nframe()
[01:29:27.632]     ...future.conditions <- base::list()
[01:29:27.632]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.632]     if (FALSE) {
[01:29:27.632]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.632]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.632]     }
[01:29:27.632]     ...future.result <- base::tryCatch({
[01:29:27.632]         base::withCallingHandlers({
[01:29:27.632]             ...future.value <- base::withVisible(base::local({
[01:29:27.632]                 sample(x, size = 1L)
[01:29:27.632]             }))
[01:29:27.632]             future::FutureResult(value = ...future.value$value, 
[01:29:27.632]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.632]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.632]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.632]                     ...future.globalenv.names))
[01:29:27.632]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.632]         }, condition = base::local({
[01:29:27.632]             c <- base::c
[01:29:27.632]             inherits <- base::inherits
[01:29:27.632]             invokeRestart <- base::invokeRestart
[01:29:27.632]             length <- base::length
[01:29:27.632]             list <- base::list
[01:29:27.632]             seq.int <- base::seq.int
[01:29:27.632]             signalCondition <- base::signalCondition
[01:29:27.632]             sys.calls <- base::sys.calls
[01:29:27.632]             `[[` <- base::`[[`
[01:29:27.632]             `+` <- base::`+`
[01:29:27.632]             `<<-` <- base::`<<-`
[01:29:27.632]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.632]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.632]                   3L)]
[01:29:27.632]             }
[01:29:27.632]             function(cond) {
[01:29:27.632]                 is_error <- inherits(cond, "error")
[01:29:27.632]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.632]                   NULL)
[01:29:27.632]                 if (is_error) {
[01:29:27.632]                   sessionInformation <- function() {
[01:29:27.632]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.632]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.632]                       search = base::search(), system = base::Sys.info())
[01:29:27.632]                   }
[01:29:27.632]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.632]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.632]                     cond$call), session = sessionInformation(), 
[01:29:27.632]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.632]                   signalCondition(cond)
[01:29:27.632]                 }
[01:29:27.632]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.632]                 "immediateCondition"))) {
[01:29:27.632]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.632]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.632]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.632]                   if (TRUE && !signal) {
[01:29:27.632]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.632]                     {
[01:29:27.632]                       inherits <- base::inherits
[01:29:27.632]                       invokeRestart <- base::invokeRestart
[01:29:27.632]                       is.null <- base::is.null
[01:29:27.632]                       muffled <- FALSE
[01:29:27.632]                       if (inherits(cond, "message")) {
[01:29:27.632]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.632]                         if (muffled) 
[01:29:27.632]                           invokeRestart("muffleMessage")
[01:29:27.632]                       }
[01:29:27.632]                       else if (inherits(cond, "warning")) {
[01:29:27.632]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.632]                         if (muffled) 
[01:29:27.632]                           invokeRestart("muffleWarning")
[01:29:27.632]                       }
[01:29:27.632]                       else if (inherits(cond, "condition")) {
[01:29:27.632]                         if (!is.null(pattern)) {
[01:29:27.632]                           computeRestarts <- base::computeRestarts
[01:29:27.632]                           grepl <- base::grepl
[01:29:27.632]                           restarts <- computeRestarts(cond)
[01:29:27.632]                           for (restart in restarts) {
[01:29:27.632]                             name <- restart$name
[01:29:27.632]                             if (is.null(name)) 
[01:29:27.632]                               next
[01:29:27.632]                             if (!grepl(pattern, name)) 
[01:29:27.632]                               next
[01:29:27.632]                             invokeRestart(restart)
[01:29:27.632]                             muffled <- TRUE
[01:29:27.632]                             break
[01:29:27.632]                           }
[01:29:27.632]                         }
[01:29:27.632]                       }
[01:29:27.632]                       invisible(muffled)
[01:29:27.632]                     }
[01:29:27.632]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.632]                   }
[01:29:27.632]                 }
[01:29:27.632]                 else {
[01:29:27.632]                   if (TRUE) {
[01:29:27.632]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.632]                     {
[01:29:27.632]                       inherits <- base::inherits
[01:29:27.632]                       invokeRestart <- base::invokeRestart
[01:29:27.632]                       is.null <- base::is.null
[01:29:27.632]                       muffled <- FALSE
[01:29:27.632]                       if (inherits(cond, "message")) {
[01:29:27.632]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.632]                         if (muffled) 
[01:29:27.632]                           invokeRestart("muffleMessage")
[01:29:27.632]                       }
[01:29:27.632]                       else if (inherits(cond, "warning")) {
[01:29:27.632]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.632]                         if (muffled) 
[01:29:27.632]                           invokeRestart("muffleWarning")
[01:29:27.632]                       }
[01:29:27.632]                       else if (inherits(cond, "condition")) {
[01:29:27.632]                         if (!is.null(pattern)) {
[01:29:27.632]                           computeRestarts <- base::computeRestarts
[01:29:27.632]                           grepl <- base::grepl
[01:29:27.632]                           restarts <- computeRestarts(cond)
[01:29:27.632]                           for (restart in restarts) {
[01:29:27.632]                             name <- restart$name
[01:29:27.632]                             if (is.null(name)) 
[01:29:27.632]                               next
[01:29:27.632]                             if (!grepl(pattern, name)) 
[01:29:27.632]                               next
[01:29:27.632]                             invokeRestart(restart)
[01:29:27.632]                             muffled <- TRUE
[01:29:27.632]                             break
[01:29:27.632]                           }
[01:29:27.632]                         }
[01:29:27.632]                       }
[01:29:27.632]                       invisible(muffled)
[01:29:27.632]                     }
[01:29:27.632]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.632]                   }
[01:29:27.632]                 }
[01:29:27.632]             }
[01:29:27.632]         }))
[01:29:27.632]     }, error = function(ex) {
[01:29:27.632]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.632]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.632]                 ...future.rng), started = ...future.startTime, 
[01:29:27.632]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.632]             version = "1.8"), class = "FutureResult")
[01:29:27.632]     }, finally = {
[01:29:27.632]         if (!identical(...future.workdir, getwd())) 
[01:29:27.632]             setwd(...future.workdir)
[01:29:27.632]         {
[01:29:27.632]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.632]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.632]             }
[01:29:27.632]             base::options(...future.oldOptions)
[01:29:27.632]             if (.Platform$OS.type == "windows") {
[01:29:27.632]                 old_names <- names(...future.oldEnvVars)
[01:29:27.632]                 envs <- base::Sys.getenv()
[01:29:27.632]                 names <- names(envs)
[01:29:27.632]                 common <- intersect(names, old_names)
[01:29:27.632]                 added <- setdiff(names, old_names)
[01:29:27.632]                 removed <- setdiff(old_names, names)
[01:29:27.632]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.632]                   envs[common]]
[01:29:27.632]                 NAMES <- toupper(changed)
[01:29:27.632]                 args <- list()
[01:29:27.632]                 for (kk in seq_along(NAMES)) {
[01:29:27.632]                   name <- changed[[kk]]
[01:29:27.632]                   NAME <- NAMES[[kk]]
[01:29:27.632]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.632]                     next
[01:29:27.632]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.632]                 }
[01:29:27.632]                 NAMES <- toupper(added)
[01:29:27.632]                 for (kk in seq_along(NAMES)) {
[01:29:27.632]                   name <- added[[kk]]
[01:29:27.632]                   NAME <- NAMES[[kk]]
[01:29:27.632]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.632]                     next
[01:29:27.632]                   args[[name]] <- ""
[01:29:27.632]                 }
[01:29:27.632]                 NAMES <- toupper(removed)
[01:29:27.632]                 for (kk in seq_along(NAMES)) {
[01:29:27.632]                   name <- removed[[kk]]
[01:29:27.632]                   NAME <- NAMES[[kk]]
[01:29:27.632]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.632]                     next
[01:29:27.632]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.632]                 }
[01:29:27.632]                 if (length(args) > 0) 
[01:29:27.632]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.632]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.632]             }
[01:29:27.632]             else {
[01:29:27.632]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.632]             }
[01:29:27.632]             {
[01:29:27.632]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.632]                   0L) {
[01:29:27.632]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.632]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.632]                   base::options(opts)
[01:29:27.632]                 }
[01:29:27.632]                 {
[01:29:27.632]                   {
[01:29:27.632]                     base::assign(".Random.seed", c(10407L, -1638694753L, 
[01:29:27.632]                     -1322645656L, -464764483L, 1355433907L, -877075751L, 
[01:29:27.632]                     1602385273L), envir = base::globalenv(), 
[01:29:27.632]                       inherits = FALSE)
[01:29:27.632]                     NULL
[01:29:27.632]                   }
[01:29:27.632]                   options(future.plan = NULL)
[01:29:27.632]                   if (is.na(NA_character_)) 
[01:29:27.632]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.632]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.632]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.632]                   {
[01:29:27.632]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.632]                     if (!future$lazy) 
[01:29:27.632]                       future <- run(future)
[01:29:27.632]                     invisible(future)
[01:29:27.632]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.632]                 }
[01:29:27.632]             }
[01:29:27.632]         }
[01:29:27.632]     })
[01:29:27.632]     if (TRUE) {
[01:29:27.632]         base::sink(type = "output", split = FALSE)
[01:29:27.632]         if (TRUE) {
[01:29:27.632]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.632]         }
[01:29:27.632]         else {
[01:29:27.632]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.632]         }
[01:29:27.632]         base::close(...future.stdout)
[01:29:27.632]         ...future.stdout <- NULL
[01:29:27.632]     }
[01:29:27.632]     ...future.result$conditions <- ...future.conditions
[01:29:27.632]     ...future.result$finished <- base::Sys.time()
[01:29:27.632]     ...future.result
[01:29:27.632] }
[01:29:27.636] assign_globals() ...
[01:29:27.637] List of 1
[01:29:27.637]  $ x: int [1:4] 0 1 2 3
[01:29:27.637]  - attr(*, "where")=List of 1
[01:29:27.637]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.637]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.637]  - attr(*, "resolved")= logi FALSE
[01:29:27.637]  - attr(*, "total_size")= num 64
[01:29:27.637]  - attr(*, "already-done")= logi TRUE
[01:29:27.642] - copied 'x' to environment
[01:29:27.643] assign_globals() ... done
[01:29:27.644] plan(): Setting new future strategy stack:
[01:29:27.644] List of future strategies:
[01:29:27.644] 1. sequential:
[01:29:27.644]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.644]    - tweaked: FALSE
[01:29:27.644]    - call: NULL
[01:29:27.645] plan(): nbrOfWorkers() = 1
[01:29:27.648] plan(): Setting new future strategy stack:
[01:29:27.649] List of future strategies:
[01:29:27.649] 1. sequential:
[01:29:27.649]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.649]    - tweaked: FALSE
[01:29:27.649]    - call: plan(strategy)
[01:29:27.650] plan(): nbrOfWorkers() = 1
[01:29:27.651] SequentialFuture started (and completed)
[01:29:27.651] - Launch lazy future ... done
[01:29:27.651] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_1-99530'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96a9ac028
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.654] getGlobalsAndPackages() ...
[01:29:27.654] Searching for globals...
[01:29:27.657] - globals found: [3] '{', 'sample', 'x'
[01:29:27.657] Searching for globals ... DONE
[01:29:27.657] Resolving globals: FALSE
[01:29:27.659] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.660] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.660] - globals: [1] 'x'
[01:29:27.660] 
[01:29:27.661] getGlobalsAndPackages() ... DONE
[01:29:27.661] run() for 'Future' ...
[01:29:27.662] - state: 'created'
[01:29:27.662] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.663] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.664] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.664]   - Field: 'label'
[01:29:27.664]   - Field: 'local'
[01:29:27.665]   - Field: 'owner'
[01:29:27.665]   - Field: 'envir'
[01:29:27.666]   - Field: 'packages'
[01:29:27.666]   - Field: 'gc'
[01:29:27.666]   - Field: 'conditions'
[01:29:27.667]   - Field: 'expr'
[01:29:27.667]   - Field: 'uuid'
[01:29:27.668]   - Field: 'seed'
[01:29:27.668]   - Field: 'version'
[01:29:27.668]   - Field: 'result'
[01:29:27.669]   - Field: 'asynchronous'
[01:29:27.674]   - Field: 'calls'
[01:29:27.675]   - Field: 'globals'
[01:29:27.675]   - Field: 'stdout'
[01:29:27.676]   - Field: 'earlySignal'
[01:29:27.676]   - Field: 'lazy'
[01:29:27.676]   - Field: 'state'
[01:29:27.677] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.677] - Launch lazy future ...
[01:29:27.677] Packages needed by the future expression (n = 0): <none>
[01:29:27.678] Packages needed by future strategies (n = 0): <none>
[01:29:27.679] {
[01:29:27.679]     {
[01:29:27.679]         {
[01:29:27.679]             ...future.startTime <- base::Sys.time()
[01:29:27.679]             {
[01:29:27.679]                 {
[01:29:27.679]                   {
[01:29:27.679]                     base::local({
[01:29:27.679]                       has_future <- base::requireNamespace("future", 
[01:29:27.679]                         quietly = TRUE)
[01:29:27.679]                       if (has_future) {
[01:29:27.679]                         ns <- base::getNamespace("future")
[01:29:27.679]                         version <- ns[[".package"]][["version"]]
[01:29:27.679]                         if (is.null(version)) 
[01:29:27.679]                           version <- utils::packageVersion("future")
[01:29:27.679]                       }
[01:29:27.679]                       else {
[01:29:27.679]                         version <- NULL
[01:29:27.679]                       }
[01:29:27.679]                       if (!has_future || version < "1.8.0") {
[01:29:27.679]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.679]                           "", base::R.version$version.string), 
[01:29:27.679]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.679]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.679]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.679]                             "release", "version")], collapse = " "), 
[01:29:27.679]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.679]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.679]                           info)
[01:29:27.679]                         info <- base::paste(info, collapse = "; ")
[01:29:27.679]                         if (!has_future) {
[01:29:27.679]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.679]                             info)
[01:29:27.679]                         }
[01:29:27.679]                         else {
[01:29:27.679]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.679]                             info, version)
[01:29:27.679]                         }
[01:29:27.679]                         base::stop(msg)
[01:29:27.679]                       }
[01:29:27.679]                     })
[01:29:27.679]                   }
[01:29:27.679]                   options(future.plan = NULL)
[01:29:27.679]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.679]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.679]                 }
[01:29:27.679]                 ...future.workdir <- getwd()
[01:29:27.679]             }
[01:29:27.679]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.679]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.679]         }
[01:29:27.679]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.679]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.679]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.679]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.679]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.679]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.679]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.679]             base::names(...future.oldOptions))
[01:29:27.679]     }
[01:29:27.679]     if (FALSE) {
[01:29:27.679]     }
[01:29:27.679]     else {
[01:29:27.679]         if (TRUE) {
[01:29:27.679]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.679]                 open = "w")
[01:29:27.679]         }
[01:29:27.679]         else {
[01:29:27.679]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.679]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.679]         }
[01:29:27.679]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.679]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.679]             base::sink(type = "output", split = FALSE)
[01:29:27.679]             base::close(...future.stdout)
[01:29:27.679]         }, add = TRUE)
[01:29:27.679]     }
[01:29:27.679]     ...future.frame <- base::sys.nframe()
[01:29:27.679]     ...future.conditions <- base::list()
[01:29:27.679]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.679]     if (FALSE) {
[01:29:27.679]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.679]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.679]     }
[01:29:27.679]     ...future.result <- base::tryCatch({
[01:29:27.679]         base::withCallingHandlers({
[01:29:27.679]             ...future.value <- base::withVisible(base::local({
[01:29:27.679]                 sample(x, size = 1L)
[01:29:27.679]             }))
[01:29:27.679]             future::FutureResult(value = ...future.value$value, 
[01:29:27.679]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.679]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.679]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.679]                     ...future.globalenv.names))
[01:29:27.679]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.679]         }, condition = base::local({
[01:29:27.679]             c <- base::c
[01:29:27.679]             inherits <- base::inherits
[01:29:27.679]             invokeRestart <- base::invokeRestart
[01:29:27.679]             length <- base::length
[01:29:27.679]             list <- base::list
[01:29:27.679]             seq.int <- base::seq.int
[01:29:27.679]             signalCondition <- base::signalCondition
[01:29:27.679]             sys.calls <- base::sys.calls
[01:29:27.679]             `[[` <- base::`[[`
[01:29:27.679]             `+` <- base::`+`
[01:29:27.679]             `<<-` <- base::`<<-`
[01:29:27.679]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.679]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.679]                   3L)]
[01:29:27.679]             }
[01:29:27.679]             function(cond) {
[01:29:27.679]                 is_error <- inherits(cond, "error")
[01:29:27.679]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.679]                   NULL)
[01:29:27.679]                 if (is_error) {
[01:29:27.679]                   sessionInformation <- function() {
[01:29:27.679]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.679]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.679]                       search = base::search(), system = base::Sys.info())
[01:29:27.679]                   }
[01:29:27.679]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.679]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.679]                     cond$call), session = sessionInformation(), 
[01:29:27.679]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.679]                   signalCondition(cond)
[01:29:27.679]                 }
[01:29:27.679]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.679]                 "immediateCondition"))) {
[01:29:27.679]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.679]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.679]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.679]                   if (TRUE && !signal) {
[01:29:27.679]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.679]                     {
[01:29:27.679]                       inherits <- base::inherits
[01:29:27.679]                       invokeRestart <- base::invokeRestart
[01:29:27.679]                       is.null <- base::is.null
[01:29:27.679]                       muffled <- FALSE
[01:29:27.679]                       if (inherits(cond, "message")) {
[01:29:27.679]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.679]                         if (muffled) 
[01:29:27.679]                           invokeRestart("muffleMessage")
[01:29:27.679]                       }
[01:29:27.679]                       else if (inherits(cond, "warning")) {
[01:29:27.679]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.679]                         if (muffled) 
[01:29:27.679]                           invokeRestart("muffleWarning")
[01:29:27.679]                       }
[01:29:27.679]                       else if (inherits(cond, "condition")) {
[01:29:27.679]                         if (!is.null(pattern)) {
[01:29:27.679]                           computeRestarts <- base::computeRestarts
[01:29:27.679]                           grepl <- base::grepl
[01:29:27.679]                           restarts <- computeRestarts(cond)
[01:29:27.679]                           for (restart in restarts) {
[01:29:27.679]                             name <- restart$name
[01:29:27.679]                             if (is.null(name)) 
[01:29:27.679]                               next
[01:29:27.679]                             if (!grepl(pattern, name)) 
[01:29:27.679]                               next
[01:29:27.679]                             invokeRestart(restart)
[01:29:27.679]                             muffled <- TRUE
[01:29:27.679]                             break
[01:29:27.679]                           }
[01:29:27.679]                         }
[01:29:27.679]                       }
[01:29:27.679]                       invisible(muffled)
[01:29:27.679]                     }
[01:29:27.679]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.679]                   }
[01:29:27.679]                 }
[01:29:27.679]                 else {
[01:29:27.679]                   if (TRUE) {
[01:29:27.679]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.679]                     {
[01:29:27.679]                       inherits <- base::inherits
[01:29:27.679]                       invokeRestart <- base::invokeRestart
[01:29:27.679]                       is.null <- base::is.null
[01:29:27.679]                       muffled <- FALSE
[01:29:27.679]                       if (inherits(cond, "message")) {
[01:29:27.679]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.679]                         if (muffled) 
[01:29:27.679]                           invokeRestart("muffleMessage")
[01:29:27.679]                       }
[01:29:27.679]                       else if (inherits(cond, "warning")) {
[01:29:27.679]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.679]                         if (muffled) 
[01:29:27.679]                           invokeRestart("muffleWarning")
[01:29:27.679]                       }
[01:29:27.679]                       else if (inherits(cond, "condition")) {
[01:29:27.679]                         if (!is.null(pattern)) {
[01:29:27.679]                           computeRestarts <- base::computeRestarts
[01:29:27.679]                           grepl <- base::grepl
[01:29:27.679]                           restarts <- computeRestarts(cond)
[01:29:27.679]                           for (restart in restarts) {
[01:29:27.679]                             name <- restart$name
[01:29:27.679]                             if (is.null(name)) 
[01:29:27.679]                               next
[01:29:27.679]                             if (!grepl(pattern, name)) 
[01:29:27.679]                               next
[01:29:27.679]                             invokeRestart(restart)
[01:29:27.679]                             muffled <- TRUE
[01:29:27.679]                             break
[01:29:27.679]                           }
[01:29:27.679]                         }
[01:29:27.679]                       }
[01:29:27.679]                       invisible(muffled)
[01:29:27.679]                     }
[01:29:27.679]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.679]                   }
[01:29:27.679]                 }
[01:29:27.679]             }
[01:29:27.679]         }))
[01:29:27.679]     }, error = function(ex) {
[01:29:27.679]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.679]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.679]                 ...future.rng), started = ...future.startTime, 
[01:29:27.679]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.679]             version = "1.8"), class = "FutureResult")
[01:29:27.679]     }, finally = {
[01:29:27.679]         if (!identical(...future.workdir, getwd())) 
[01:29:27.679]             setwd(...future.workdir)
[01:29:27.679]         {
[01:29:27.679]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.679]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.679]             }
[01:29:27.679]             base::options(...future.oldOptions)
[01:29:27.679]             if (.Platform$OS.type == "windows") {
[01:29:27.679]                 old_names <- names(...future.oldEnvVars)
[01:29:27.679]                 envs <- base::Sys.getenv()
[01:29:27.679]                 names <- names(envs)
[01:29:27.679]                 common <- intersect(names, old_names)
[01:29:27.679]                 added <- setdiff(names, old_names)
[01:29:27.679]                 removed <- setdiff(old_names, names)
[01:29:27.679]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.679]                   envs[common]]
[01:29:27.679]                 NAMES <- toupper(changed)
[01:29:27.679]                 args <- list()
[01:29:27.679]                 for (kk in seq_along(NAMES)) {
[01:29:27.679]                   name <- changed[[kk]]
[01:29:27.679]                   NAME <- NAMES[[kk]]
[01:29:27.679]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.679]                     next
[01:29:27.679]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.679]                 }
[01:29:27.679]                 NAMES <- toupper(added)
[01:29:27.679]                 for (kk in seq_along(NAMES)) {
[01:29:27.679]                   name <- added[[kk]]
[01:29:27.679]                   NAME <- NAMES[[kk]]
[01:29:27.679]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.679]                     next
[01:29:27.679]                   args[[name]] <- ""
[01:29:27.679]                 }
[01:29:27.679]                 NAMES <- toupper(removed)
[01:29:27.679]                 for (kk in seq_along(NAMES)) {
[01:29:27.679]                   name <- removed[[kk]]
[01:29:27.679]                   NAME <- NAMES[[kk]]
[01:29:27.679]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.679]                     next
[01:29:27.679]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.679]                 }
[01:29:27.679]                 if (length(args) > 0) 
[01:29:27.679]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.679]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.679]             }
[01:29:27.679]             else {
[01:29:27.679]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.679]             }
[01:29:27.679]             {
[01:29:27.679]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.679]                   0L) {
[01:29:27.679]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.679]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.679]                   base::options(opts)
[01:29:27.679]                 }
[01:29:27.679]                 {
[01:29:27.679]                   {
[01:29:27.679]                     base::assign(".Random.seed", c(10407L, -464764483L, 
[01:29:27.679]                     -151635093L, 1386553462L, 1602385273L, 415878624L, 
[01:29:27.679]                     -450284196L), envir = base::globalenv(), 
[01:29:27.679]                       inherits = FALSE)
[01:29:27.679]                     NULL
[01:29:27.679]                   }
[01:29:27.679]                   options(future.plan = NULL)
[01:29:27.679]                   if (is.na(NA_character_)) 
[01:29:27.679]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.679]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.679]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.679]                   {
[01:29:27.679]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.679]                     if (!future$lazy) 
[01:29:27.679]                       future <- run(future)
[01:29:27.679]                     invisible(future)
[01:29:27.679]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.679]                 }
[01:29:27.679]             }
[01:29:27.679]         }
[01:29:27.679]     })
[01:29:27.679]     if (TRUE) {
[01:29:27.679]         base::sink(type = "output", split = FALSE)
[01:29:27.679]         if (TRUE) {
[01:29:27.679]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.679]         }
[01:29:27.679]         else {
[01:29:27.679]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.679]         }
[01:29:27.679]         base::close(...future.stdout)
[01:29:27.679]         ...future.stdout <- NULL
[01:29:27.679]     }
[01:29:27.679]     ...future.result$conditions <- ...future.conditions
[01:29:27.679]     ...future.result$finished <- base::Sys.time()
[01:29:27.679]     ...future.result
[01:29:27.679] }
[01:29:27.684] assign_globals() ...
[01:29:27.684] List of 1
[01:29:27.684]  $ x: int [1:4] 0 1 2 3
[01:29:27.684]  - attr(*, "where")=List of 1
[01:29:27.684]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.684]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.684]  - attr(*, "resolved")= logi FALSE
[01:29:27.684]  - attr(*, "total_size")= num 64
[01:29:27.684]  - attr(*, "already-done")= logi TRUE
[01:29:27.688] - copied 'x' to environment
[01:29:27.688] assign_globals() ... done
[01:29:27.689] plan(): Setting new future strategy stack:
[01:29:27.689] List of future strategies:
[01:29:27.689] 1. sequential:
[01:29:27.689]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.689]    - tweaked: FALSE
[01:29:27.689]    - call: NULL
[01:29:27.690] plan(): nbrOfWorkers() = 1
[01:29:27.692] plan(): Setting new future strategy stack:
[01:29:27.692] List of future strategies:
[01:29:27.692] 1. sequential:
[01:29:27.692]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.692]    - tweaked: FALSE
[01:29:27.692]    - call: plan(strategy)
[01:29:27.693] plan(): nbrOfWorkers() = 1
[01:29:27.693] SequentialFuture started (and completed)
[01:29:27.693] - Launch lazy future ... done
[01:29:27.694] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_2-814460'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96a9ac028
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.695] getGlobalsAndPackages() ...
[01:29:27.695] Searching for globals...
[01:29:27.697] - globals found: [3] '{', 'sample', 'x'
[01:29:27.697] Searching for globals ... DONE
[01:29:27.697] Resolving globals: FALSE
[01:29:27.698] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.699] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.699] - globals: [1] 'x'
[01:29:27.699] 
[01:29:27.699] getGlobalsAndPackages() ... DONE
[01:29:27.700] run() for 'Future' ...
[01:29:27.700] - state: 'created'
[01:29:27.700] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.701] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.701] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.701]   - Field: 'label'
[01:29:27.701]   - Field: 'local'
[01:29:27.702]   - Field: 'owner'
[01:29:27.702]   - Field: 'envir'
[01:29:27.702]   - Field: 'packages'
[01:29:27.702]   - Field: 'gc'
[01:29:27.702]   - Field: 'conditions'
[01:29:27.703]   - Field: 'expr'
[01:29:27.703]   - Field: 'uuid'
[01:29:27.703]   - Field: 'seed'
[01:29:27.703]   - Field: 'version'
[01:29:27.703]   - Field: 'result'
[01:29:27.704]   - Field: 'asynchronous'
[01:29:27.704]   - Field: 'calls'
[01:29:27.704]   - Field: 'globals'
[01:29:27.704]   - Field: 'stdout'
[01:29:27.705]   - Field: 'earlySignal'
[01:29:27.705]   - Field: 'lazy'
[01:29:27.705]   - Field: 'state'
[01:29:27.705] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.706] - Launch lazy future ...
[01:29:27.706] Packages needed by the future expression (n = 0): <none>
[01:29:27.706] Packages needed by future strategies (n = 0): <none>
[01:29:27.707] {
[01:29:27.707]     {
[01:29:27.707]         {
[01:29:27.707]             ...future.startTime <- base::Sys.time()
[01:29:27.707]             {
[01:29:27.707]                 {
[01:29:27.707]                   {
[01:29:27.707]                     base::local({
[01:29:27.707]                       has_future <- base::requireNamespace("future", 
[01:29:27.707]                         quietly = TRUE)
[01:29:27.707]                       if (has_future) {
[01:29:27.707]                         ns <- base::getNamespace("future")
[01:29:27.707]                         version <- ns[[".package"]][["version"]]
[01:29:27.707]                         if (is.null(version)) 
[01:29:27.707]                           version <- utils::packageVersion("future")
[01:29:27.707]                       }
[01:29:27.707]                       else {
[01:29:27.707]                         version <- NULL
[01:29:27.707]                       }
[01:29:27.707]                       if (!has_future || version < "1.8.0") {
[01:29:27.707]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.707]                           "", base::R.version$version.string), 
[01:29:27.707]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.707]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.707]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.707]                             "release", "version")], collapse = " "), 
[01:29:27.707]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.707]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.707]                           info)
[01:29:27.707]                         info <- base::paste(info, collapse = "; ")
[01:29:27.707]                         if (!has_future) {
[01:29:27.707]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.707]                             info)
[01:29:27.707]                         }
[01:29:27.707]                         else {
[01:29:27.707]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.707]                             info, version)
[01:29:27.707]                         }
[01:29:27.707]                         base::stop(msg)
[01:29:27.707]                       }
[01:29:27.707]                     })
[01:29:27.707]                   }
[01:29:27.707]                   options(future.plan = NULL)
[01:29:27.707]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.707]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.707]                 }
[01:29:27.707]                 ...future.workdir <- getwd()
[01:29:27.707]             }
[01:29:27.707]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.707]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.707]         }
[01:29:27.707]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.707]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.707]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.707]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.707]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.707]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.707]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.707]             base::names(...future.oldOptions))
[01:29:27.707]     }
[01:29:27.707]     if (FALSE) {
[01:29:27.707]     }
[01:29:27.707]     else {
[01:29:27.707]         if (TRUE) {
[01:29:27.707]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.707]                 open = "w")
[01:29:27.707]         }
[01:29:27.707]         else {
[01:29:27.707]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.707]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.707]         }
[01:29:27.707]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.707]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.707]             base::sink(type = "output", split = FALSE)
[01:29:27.707]             base::close(...future.stdout)
[01:29:27.707]         }, add = TRUE)
[01:29:27.707]     }
[01:29:27.707]     ...future.frame <- base::sys.nframe()
[01:29:27.707]     ...future.conditions <- base::list()
[01:29:27.707]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.707]     if (FALSE) {
[01:29:27.707]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.707]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.707]     }
[01:29:27.707]     ...future.result <- base::tryCatch({
[01:29:27.707]         base::withCallingHandlers({
[01:29:27.707]             ...future.value <- base::withVisible(base::local({
[01:29:27.707]                 sample(x, size = 1L)
[01:29:27.707]             }))
[01:29:27.707]             future::FutureResult(value = ...future.value$value, 
[01:29:27.707]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.707]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.707]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.707]                     ...future.globalenv.names))
[01:29:27.707]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.707]         }, condition = base::local({
[01:29:27.707]             c <- base::c
[01:29:27.707]             inherits <- base::inherits
[01:29:27.707]             invokeRestart <- base::invokeRestart
[01:29:27.707]             length <- base::length
[01:29:27.707]             list <- base::list
[01:29:27.707]             seq.int <- base::seq.int
[01:29:27.707]             signalCondition <- base::signalCondition
[01:29:27.707]             sys.calls <- base::sys.calls
[01:29:27.707]             `[[` <- base::`[[`
[01:29:27.707]             `+` <- base::`+`
[01:29:27.707]             `<<-` <- base::`<<-`
[01:29:27.707]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.707]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.707]                   3L)]
[01:29:27.707]             }
[01:29:27.707]             function(cond) {
[01:29:27.707]                 is_error <- inherits(cond, "error")
[01:29:27.707]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.707]                   NULL)
[01:29:27.707]                 if (is_error) {
[01:29:27.707]                   sessionInformation <- function() {
[01:29:27.707]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.707]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.707]                       search = base::search(), system = base::Sys.info())
[01:29:27.707]                   }
[01:29:27.707]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.707]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.707]                     cond$call), session = sessionInformation(), 
[01:29:27.707]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.707]                   signalCondition(cond)
[01:29:27.707]                 }
[01:29:27.707]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.707]                 "immediateCondition"))) {
[01:29:27.707]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.707]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.707]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.707]                   if (TRUE && !signal) {
[01:29:27.707]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.707]                     {
[01:29:27.707]                       inherits <- base::inherits
[01:29:27.707]                       invokeRestart <- base::invokeRestart
[01:29:27.707]                       is.null <- base::is.null
[01:29:27.707]                       muffled <- FALSE
[01:29:27.707]                       if (inherits(cond, "message")) {
[01:29:27.707]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.707]                         if (muffled) 
[01:29:27.707]                           invokeRestart("muffleMessage")
[01:29:27.707]                       }
[01:29:27.707]                       else if (inherits(cond, "warning")) {
[01:29:27.707]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.707]                         if (muffled) 
[01:29:27.707]                           invokeRestart("muffleWarning")
[01:29:27.707]                       }
[01:29:27.707]                       else if (inherits(cond, "condition")) {
[01:29:27.707]                         if (!is.null(pattern)) {
[01:29:27.707]                           computeRestarts <- base::computeRestarts
[01:29:27.707]                           grepl <- base::grepl
[01:29:27.707]                           restarts <- computeRestarts(cond)
[01:29:27.707]                           for (restart in restarts) {
[01:29:27.707]                             name <- restart$name
[01:29:27.707]                             if (is.null(name)) 
[01:29:27.707]                               next
[01:29:27.707]                             if (!grepl(pattern, name)) 
[01:29:27.707]                               next
[01:29:27.707]                             invokeRestart(restart)
[01:29:27.707]                             muffled <- TRUE
[01:29:27.707]                             break
[01:29:27.707]                           }
[01:29:27.707]                         }
[01:29:27.707]                       }
[01:29:27.707]                       invisible(muffled)
[01:29:27.707]                     }
[01:29:27.707]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.707]                   }
[01:29:27.707]                 }
[01:29:27.707]                 else {
[01:29:27.707]                   if (TRUE) {
[01:29:27.707]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.707]                     {
[01:29:27.707]                       inherits <- base::inherits
[01:29:27.707]                       invokeRestart <- base::invokeRestart
[01:29:27.707]                       is.null <- base::is.null
[01:29:27.707]                       muffled <- FALSE
[01:29:27.707]                       if (inherits(cond, "message")) {
[01:29:27.707]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.707]                         if (muffled) 
[01:29:27.707]                           invokeRestart("muffleMessage")
[01:29:27.707]                       }
[01:29:27.707]                       else if (inherits(cond, "warning")) {
[01:29:27.707]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.707]                         if (muffled) 
[01:29:27.707]                           invokeRestart("muffleWarning")
[01:29:27.707]                       }
[01:29:27.707]                       else if (inherits(cond, "condition")) {
[01:29:27.707]                         if (!is.null(pattern)) {
[01:29:27.707]                           computeRestarts <- base::computeRestarts
[01:29:27.707]                           grepl <- base::grepl
[01:29:27.707]                           restarts <- computeRestarts(cond)
[01:29:27.707]                           for (restart in restarts) {
[01:29:27.707]                             name <- restart$name
[01:29:27.707]                             if (is.null(name)) 
[01:29:27.707]                               next
[01:29:27.707]                             if (!grepl(pattern, name)) 
[01:29:27.707]                               next
[01:29:27.707]                             invokeRestart(restart)
[01:29:27.707]                             muffled <- TRUE
[01:29:27.707]                             break
[01:29:27.707]                           }
[01:29:27.707]                         }
[01:29:27.707]                       }
[01:29:27.707]                       invisible(muffled)
[01:29:27.707]                     }
[01:29:27.707]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.707]                   }
[01:29:27.707]                 }
[01:29:27.707]             }
[01:29:27.707]         }))
[01:29:27.707]     }, error = function(ex) {
[01:29:27.707]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.707]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.707]                 ...future.rng), started = ...future.startTime, 
[01:29:27.707]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.707]             version = "1.8"), class = "FutureResult")
[01:29:27.707]     }, finally = {
[01:29:27.707]         if (!identical(...future.workdir, getwd())) 
[01:29:27.707]             setwd(...future.workdir)
[01:29:27.707]         {
[01:29:27.707]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.707]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.707]             }
[01:29:27.707]             base::options(...future.oldOptions)
[01:29:27.707]             if (.Platform$OS.type == "windows") {
[01:29:27.707]                 old_names <- names(...future.oldEnvVars)
[01:29:27.707]                 envs <- base::Sys.getenv()
[01:29:27.707]                 names <- names(envs)
[01:29:27.707]                 common <- intersect(names, old_names)
[01:29:27.707]                 added <- setdiff(names, old_names)
[01:29:27.707]                 removed <- setdiff(old_names, names)
[01:29:27.707]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.707]                   envs[common]]
[01:29:27.707]                 NAMES <- toupper(changed)
[01:29:27.707]                 args <- list()
[01:29:27.707]                 for (kk in seq_along(NAMES)) {
[01:29:27.707]                   name <- changed[[kk]]
[01:29:27.707]                   NAME <- NAMES[[kk]]
[01:29:27.707]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.707]                     next
[01:29:27.707]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.707]                 }
[01:29:27.707]                 NAMES <- toupper(added)
[01:29:27.707]                 for (kk in seq_along(NAMES)) {
[01:29:27.707]                   name <- added[[kk]]
[01:29:27.707]                   NAME <- NAMES[[kk]]
[01:29:27.707]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.707]                     next
[01:29:27.707]                   args[[name]] <- ""
[01:29:27.707]                 }
[01:29:27.707]                 NAMES <- toupper(removed)
[01:29:27.707]                 for (kk in seq_along(NAMES)) {
[01:29:27.707]                   name <- removed[[kk]]
[01:29:27.707]                   NAME <- NAMES[[kk]]
[01:29:27.707]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.707]                     next
[01:29:27.707]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.707]                 }
[01:29:27.707]                 if (length(args) > 0) 
[01:29:27.707]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.707]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.707]             }
[01:29:27.707]             else {
[01:29:27.707]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.707]             }
[01:29:27.707]             {
[01:29:27.707]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.707]                   0L) {
[01:29:27.707]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.707]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.707]                   base::options(opts)
[01:29:27.707]                 }
[01:29:27.707]                 {
[01:29:27.707]                   {
[01:29:27.707]                     base::assign(".Random.seed", c(10407L, 1386553462L, 
[01:29:27.707]                     1056333440L, -1269930425L, -450284196L, -1698591186L, 
[01:29:27.707]                     -1338438503L), envir = base::globalenv(), 
[01:29:27.707]                       inherits = FALSE)
[01:29:27.707]                     NULL
[01:29:27.707]                   }
[01:29:27.707]                   options(future.plan = NULL)
[01:29:27.707]                   if (is.na(NA_character_)) 
[01:29:27.707]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.707]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.707]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.707]                   {
[01:29:27.707]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.707]                     if (!future$lazy) 
[01:29:27.707]                       future <- run(future)
[01:29:27.707]                     invisible(future)
[01:29:27.707]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.707]                 }
[01:29:27.707]             }
[01:29:27.707]         }
[01:29:27.707]     })
[01:29:27.707]     if (TRUE) {
[01:29:27.707]         base::sink(type = "output", split = FALSE)
[01:29:27.707]         if (TRUE) {
[01:29:27.707]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.707]         }
[01:29:27.707]         else {
[01:29:27.707]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.707]         }
[01:29:27.707]         base::close(...future.stdout)
[01:29:27.707]         ...future.stdout <- NULL
[01:29:27.707]     }
[01:29:27.707]     ...future.result$conditions <- ...future.conditions
[01:29:27.707]     ...future.result$finished <- base::Sys.time()
[01:29:27.707]     ...future.result
[01:29:27.707] }
[01:29:27.711] assign_globals() ...
[01:29:27.711] List of 1
[01:29:27.711]  $ x: int [1:4] 0 1 2 3
[01:29:27.711]  - attr(*, "where")=List of 1
[01:29:27.711]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.711]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.711]  - attr(*, "resolved")= logi FALSE
[01:29:27.711]  - attr(*, "total_size")= num 64
[01:29:27.711]  - attr(*, "already-done")= logi TRUE
[01:29:27.715] - copied 'x' to environment
[01:29:27.715] assign_globals() ... done
[01:29:27.715] plan(): Setting new future strategy stack:
[01:29:27.716] List of future strategies:
[01:29:27.716] 1. sequential:
[01:29:27.716]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.716]    - tweaked: FALSE
[01:29:27.716]    - call: NULL
[01:29:27.716] plan(): nbrOfWorkers() = 1
[01:29:27.718] plan(): Setting new future strategy stack:
[01:29:27.718] List of future strategies:
[01:29:27.718] 1. sequential:
[01:29:27.718]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.718]    - tweaked: FALSE
[01:29:27.718]    - call: plan(strategy)
[01:29:27.719] plan(): nbrOfWorkers() = 1
[01:29:27.719] SequentialFuture started (and completed)
[01:29:27.719] - Launch lazy future ... done
[01:29:27.720] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_3-263190'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96a9ac028
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.722] getGlobalsAndPackages() ...
[01:29:27.722] Searching for globals...
[01:29:27.724] - globals found: [3] '{', 'sample', 'x'
[01:29:27.724] Searching for globals ... DONE
[01:29:27.724] Resolving globals: FALSE
[01:29:27.725] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.725] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.725] - globals: [1] 'x'
[01:29:27.725] 
[01:29:27.726] getGlobalsAndPackages() ... DONE
[01:29:27.726] run() for 'Future' ...
[01:29:27.726] - state: 'created'
[01:29:27.726] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.727] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.727] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.727]   - Field: 'label'
[01:29:27.727]   - Field: 'local'
[01:29:27.727]   - Field: 'owner'
[01:29:27.728]   - Field: 'envir'
[01:29:27.728]   - Field: 'packages'
[01:29:27.728]   - Field: 'gc'
[01:29:27.728]   - Field: 'conditions'
[01:29:27.728]   - Field: 'expr'
[01:29:27.728]   - Field: 'uuid'
[01:29:27.729]   - Field: 'seed'
[01:29:27.729]   - Field: 'version'
[01:29:27.729]   - Field: 'result'
[01:29:27.729]   - Field: 'asynchronous'
[01:29:27.729]   - Field: 'calls'
[01:29:27.730]   - Field: 'globals'
[01:29:27.730]   - Field: 'stdout'
[01:29:27.730]   - Field: 'earlySignal'
[01:29:27.730]   - Field: 'lazy'
[01:29:27.730]   - Field: 'state'
[01:29:27.730] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.731] - Launch lazy future ...
[01:29:27.731] Packages needed by the future expression (n = 0): <none>
[01:29:27.731] Packages needed by future strategies (n = 0): <none>
[01:29:27.732] {
[01:29:27.732]     {
[01:29:27.732]         {
[01:29:27.732]             ...future.startTime <- base::Sys.time()
[01:29:27.732]             {
[01:29:27.732]                 {
[01:29:27.732]                   {
[01:29:27.732]                     base::local({
[01:29:27.732]                       has_future <- base::requireNamespace("future", 
[01:29:27.732]                         quietly = TRUE)
[01:29:27.732]                       if (has_future) {
[01:29:27.732]                         ns <- base::getNamespace("future")
[01:29:27.732]                         version <- ns[[".package"]][["version"]]
[01:29:27.732]                         if (is.null(version)) 
[01:29:27.732]                           version <- utils::packageVersion("future")
[01:29:27.732]                       }
[01:29:27.732]                       else {
[01:29:27.732]                         version <- NULL
[01:29:27.732]                       }
[01:29:27.732]                       if (!has_future || version < "1.8.0") {
[01:29:27.732]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.732]                           "", base::R.version$version.string), 
[01:29:27.732]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:27.732]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.732]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.732]                             "release", "version")], collapse = " "), 
[01:29:27.732]                           hostname = base::Sys.info()[["nodename"]])
[01:29:27.732]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.732]                           info)
[01:29:27.732]                         info <- base::paste(info, collapse = "; ")
[01:29:27.732]                         if (!has_future) {
[01:29:27.732]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.732]                             info)
[01:29:27.732]                         }
[01:29:27.732]                         else {
[01:29:27.732]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.732]                             info, version)
[01:29:27.732]                         }
[01:29:27.732]                         base::stop(msg)
[01:29:27.732]                       }
[01:29:27.732]                     })
[01:29:27.732]                   }
[01:29:27.732]                   options(future.plan = NULL)
[01:29:27.732]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.732]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:27.732]                 }
[01:29:27.732]                 ...future.workdir <- getwd()
[01:29:27.732]             }
[01:29:27.732]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.732]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.732]         }
[01:29:27.732]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.732]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.732]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.732]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.732]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.732]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.732]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.732]             base::names(...future.oldOptions))
[01:29:27.732]     }
[01:29:27.732]     if (FALSE) {
[01:29:27.732]     }
[01:29:27.732]     else {
[01:29:27.732]         if (TRUE) {
[01:29:27.732]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.732]                 open = "w")
[01:29:27.732]         }
[01:29:27.732]         else {
[01:29:27.732]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.732]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.732]         }
[01:29:27.732]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.732]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.732]             base::sink(type = "output", split = FALSE)
[01:29:27.732]             base::close(...future.stdout)
[01:29:27.732]         }, add = TRUE)
[01:29:27.732]     }
[01:29:27.732]     ...future.frame <- base::sys.nframe()
[01:29:27.732]     ...future.conditions <- base::list()
[01:29:27.732]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.732]     if (FALSE) {
[01:29:27.732]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.732]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.732]     }
[01:29:27.732]     ...future.result <- base::tryCatch({
[01:29:27.732]         base::withCallingHandlers({
[01:29:27.732]             ...future.value <- base::withVisible(base::local({
[01:29:27.732]                 sample(x, size = 1L)
[01:29:27.732]             }))
[01:29:27.732]             future::FutureResult(value = ...future.value$value, 
[01:29:27.732]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.732]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.732]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.732]                     ...future.globalenv.names))
[01:29:27.732]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.732]         }, condition = base::local({
[01:29:27.732]             c <- base::c
[01:29:27.732]             inherits <- base::inherits
[01:29:27.732]             invokeRestart <- base::invokeRestart
[01:29:27.732]             length <- base::length
[01:29:27.732]             list <- base::list
[01:29:27.732]             seq.int <- base::seq.int
[01:29:27.732]             signalCondition <- base::signalCondition
[01:29:27.732]             sys.calls <- base::sys.calls
[01:29:27.732]             `[[` <- base::`[[`
[01:29:27.732]             `+` <- base::`+`
[01:29:27.732]             `<<-` <- base::`<<-`
[01:29:27.732]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.732]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.732]                   3L)]
[01:29:27.732]             }
[01:29:27.732]             function(cond) {
[01:29:27.732]                 is_error <- inherits(cond, "error")
[01:29:27.732]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.732]                   NULL)
[01:29:27.732]                 if (is_error) {
[01:29:27.732]                   sessionInformation <- function() {
[01:29:27.732]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.732]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.732]                       search = base::search(), system = base::Sys.info())
[01:29:27.732]                   }
[01:29:27.732]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.732]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.732]                     cond$call), session = sessionInformation(), 
[01:29:27.732]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.732]                   signalCondition(cond)
[01:29:27.732]                 }
[01:29:27.732]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.732]                 "immediateCondition"))) {
[01:29:27.732]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.732]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.732]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.732]                   if (TRUE && !signal) {
[01:29:27.732]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.732]                     {
[01:29:27.732]                       inherits <- base::inherits
[01:29:27.732]                       invokeRestart <- base::invokeRestart
[01:29:27.732]                       is.null <- base::is.null
[01:29:27.732]                       muffled <- FALSE
[01:29:27.732]                       if (inherits(cond, "message")) {
[01:29:27.732]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.732]                         if (muffled) 
[01:29:27.732]                           invokeRestart("muffleMessage")
[01:29:27.732]                       }
[01:29:27.732]                       else if (inherits(cond, "warning")) {
[01:29:27.732]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.732]                         if (muffled) 
[01:29:27.732]                           invokeRestart("muffleWarning")
[01:29:27.732]                       }
[01:29:27.732]                       else if (inherits(cond, "condition")) {
[01:29:27.732]                         if (!is.null(pattern)) {
[01:29:27.732]                           computeRestarts <- base::computeRestarts
[01:29:27.732]                           grepl <- base::grepl
[01:29:27.732]                           restarts <- computeRestarts(cond)
[01:29:27.732]                           for (restart in restarts) {
[01:29:27.732]                             name <- restart$name
[01:29:27.732]                             if (is.null(name)) 
[01:29:27.732]                               next
[01:29:27.732]                             if (!grepl(pattern, name)) 
[01:29:27.732]                               next
[01:29:27.732]                             invokeRestart(restart)
[01:29:27.732]                             muffled <- TRUE
[01:29:27.732]                             break
[01:29:27.732]                           }
[01:29:27.732]                         }
[01:29:27.732]                       }
[01:29:27.732]                       invisible(muffled)
[01:29:27.732]                     }
[01:29:27.732]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.732]                   }
[01:29:27.732]                 }
[01:29:27.732]                 else {
[01:29:27.732]                   if (TRUE) {
[01:29:27.732]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.732]                     {
[01:29:27.732]                       inherits <- base::inherits
[01:29:27.732]                       invokeRestart <- base::invokeRestart
[01:29:27.732]                       is.null <- base::is.null
[01:29:27.732]                       muffled <- FALSE
[01:29:27.732]                       if (inherits(cond, "message")) {
[01:29:27.732]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.732]                         if (muffled) 
[01:29:27.732]                           invokeRestart("muffleMessage")
[01:29:27.732]                       }
[01:29:27.732]                       else if (inherits(cond, "warning")) {
[01:29:27.732]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.732]                         if (muffled) 
[01:29:27.732]                           invokeRestart("muffleWarning")
[01:29:27.732]                       }
[01:29:27.732]                       else if (inherits(cond, "condition")) {
[01:29:27.732]                         if (!is.null(pattern)) {
[01:29:27.732]                           computeRestarts <- base::computeRestarts
[01:29:27.732]                           grepl <- base::grepl
[01:29:27.732]                           restarts <- computeRestarts(cond)
[01:29:27.732]                           for (restart in restarts) {
[01:29:27.732]                             name <- restart$name
[01:29:27.732]                             if (is.null(name)) 
[01:29:27.732]                               next
[01:29:27.732]                             if (!grepl(pattern, name)) 
[01:29:27.732]                               next
[01:29:27.732]                             invokeRestart(restart)
[01:29:27.732]                             muffled <- TRUE
[01:29:27.732]                             break
[01:29:27.732]                           }
[01:29:27.732]                         }
[01:29:27.732]                       }
[01:29:27.732]                       invisible(muffled)
[01:29:27.732]                     }
[01:29:27.732]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.732]                   }
[01:29:27.732]                 }
[01:29:27.732]             }
[01:29:27.732]         }))
[01:29:27.732]     }, error = function(ex) {
[01:29:27.732]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.732]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.732]                 ...future.rng), started = ...future.startTime, 
[01:29:27.732]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.732]             version = "1.8"), class = "FutureResult")
[01:29:27.732]     }, finally = {
[01:29:27.732]         if (!identical(...future.workdir, getwd())) 
[01:29:27.732]             setwd(...future.workdir)
[01:29:27.732]         {
[01:29:27.732]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.732]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.732]             }
[01:29:27.732]             base::options(...future.oldOptions)
[01:29:27.732]             if (.Platform$OS.type == "windows") {
[01:29:27.732]                 old_names <- names(...future.oldEnvVars)
[01:29:27.732]                 envs <- base::Sys.getenv()
[01:29:27.732]                 names <- names(envs)
[01:29:27.732]                 common <- intersect(names, old_names)
[01:29:27.732]                 added <- setdiff(names, old_names)
[01:29:27.732]                 removed <- setdiff(old_names, names)
[01:29:27.732]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.732]                   envs[common]]
[01:29:27.732]                 NAMES <- toupper(changed)
[01:29:27.732]                 args <- list()
[01:29:27.732]                 for (kk in seq_along(NAMES)) {
[01:29:27.732]                   name <- changed[[kk]]
[01:29:27.732]                   NAME <- NAMES[[kk]]
[01:29:27.732]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.732]                     next
[01:29:27.732]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.732]                 }
[01:29:27.732]                 NAMES <- toupper(added)
[01:29:27.732]                 for (kk in seq_along(NAMES)) {
[01:29:27.732]                   name <- added[[kk]]
[01:29:27.732]                   NAME <- NAMES[[kk]]
[01:29:27.732]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.732]                     next
[01:29:27.732]                   args[[name]] <- ""
[01:29:27.732]                 }
[01:29:27.732]                 NAMES <- toupper(removed)
[01:29:27.732]                 for (kk in seq_along(NAMES)) {
[01:29:27.732]                   name <- removed[[kk]]
[01:29:27.732]                   NAME <- NAMES[[kk]]
[01:29:27.732]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.732]                     next
[01:29:27.732]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.732]                 }
[01:29:27.732]                 if (length(args) > 0) 
[01:29:27.732]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.732]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.732]             }
[01:29:27.732]             else {
[01:29:27.732]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.732]             }
[01:29:27.732]             {
[01:29:27.732]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.732]                   0L) {
[01:29:27.732]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.732]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.732]                   base::options(opts)
[01:29:27.732]                 }
[01:29:27.732]                 {
[01:29:27.732]                   {
[01:29:27.732]                     base::assign(".Random.seed", c(10407L, -1269930425L, 
[01:29:27.732]                     -192946844L, 1503370635L, -1338438503L, 1874105503L, 
[01:29:27.732]                     60389135L), envir = base::globalenv(), inherits = FALSE)
[01:29:27.732]                     NULL
[01:29:27.732]                   }
[01:29:27.732]                   options(future.plan = NULL)
[01:29:27.732]                   if (is.na(NA_character_)) 
[01:29:27.732]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.732]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.732]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.732]                   {
[01:29:27.732]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.732]                     if (!future$lazy) 
[01:29:27.732]                       future <- run(future)
[01:29:27.732]                     invisible(future)
[01:29:27.732]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.732]                 }
[01:29:27.732]             }
[01:29:27.732]         }
[01:29:27.732]     })
[01:29:27.732]     if (TRUE) {
[01:29:27.732]         base::sink(type = "output", split = FALSE)
[01:29:27.732]         if (TRUE) {
[01:29:27.732]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.732]         }
[01:29:27.732]         else {
[01:29:27.732]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.732]         }
[01:29:27.732]         base::close(...future.stdout)
[01:29:27.732]         ...future.stdout <- NULL
[01:29:27.732]     }
[01:29:27.732]     ...future.result$conditions <- ...future.conditions
[01:29:27.732]     ...future.result$finished <- base::Sys.time()
[01:29:27.732]     ...future.result
[01:29:27.732] }
[01:29:27.735] assign_globals() ...
[01:29:27.736] List of 1
[01:29:27.736]  $ x: int [1:4] 0 1 2 3
[01:29:27.736]  - attr(*, "where")=List of 1
[01:29:27.736]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.736]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.736]  - attr(*, "resolved")= logi FALSE
[01:29:27.736]  - attr(*, "total_size")= num 64
[01:29:27.736]  - attr(*, "already-done")= logi TRUE
[01:29:27.739] - copied 'x' to environment
[01:29:27.739] assign_globals() ... done
[01:29:27.739] plan(): Setting new future strategy stack:
[01:29:27.739] List of future strategies:
[01:29:27.739] 1. sequential:
[01:29:27.739]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.739]    - tweaked: FALSE
[01:29:27.739]    - call: NULL
[01:29:27.740] plan(): nbrOfWorkers() = 1
[01:29:27.741] plan(): Setting new future strategy stack:
[01:29:27.741] List of future strategies:
[01:29:27.741] 1. sequential:
[01:29:27.741]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.741]    - tweaked: FALSE
[01:29:27.741]    - call: plan(strategy)
[01:29:27.742] plan(): nbrOfWorkers() = 1
[01:29:27.742] SequentialFuture started (and completed)
[01:29:27.742] - Launch lazy future ... done
[01:29:27.743] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_4-742915'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96a9ac028
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.744] resolve() on list ...
[01:29:27.744]  recursive: 0
[01:29:27.744]  length: 4
[01:29:27.744] 
[01:29:27.744] resolved() for 'SequentialFuture' ...
[01:29:27.745] - state: 'finished'
[01:29:27.745] - run: TRUE
[01:29:27.745] - result: 'FutureResult'
[01:29:27.745] resolved() for 'SequentialFuture' ... done
[01:29:27.745] Future #1
[01:29:27.746] signalConditionsASAP(SequentialFuture, pos=1) ...
[01:29:27.746] - nx: 4
[01:29:27.746] - relay: TRUE
[01:29:27.746] - stdout: TRUE
[01:29:27.746] - signal: TRUE
[01:29:27.746] - resignal: FALSE
[01:29:27.746] - force: TRUE
[01:29:27.747] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:27.747] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:27.747]  - until=1
[01:29:27.747]  - relaying element #1
[01:29:27.747] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:27.748] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:27.748] signalConditionsASAP(SequentialFuture, pos=1) ... done
[01:29:27.748]  length: 3 (resolved future 1)
[01:29:27.748] resolved() for 'SequentialFuture' ...
[01:29:27.748] - state: 'finished'
[01:29:27.748] - run: TRUE
[01:29:27.749] - result: 'FutureResult'
[01:29:27.749] resolved() for 'SequentialFuture' ... done
[01:29:27.749] Future #2
[01:29:27.749] signalConditionsASAP(SequentialFuture, pos=2) ...
[01:29:27.749] - nx: 4
[01:29:27.750] - relay: TRUE
[01:29:27.750] - stdout: TRUE
[01:29:27.750] - signal: TRUE
[01:29:27.750] - resignal: FALSE
[01:29:27.750] - force: TRUE
[01:29:27.750] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:27.750] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:27.751]  - until=2
[01:29:27.751]  - relaying element #2
[01:29:27.751] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:27.751] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:27.751] signalConditionsASAP(SequentialFuture, pos=2) ... done
[01:29:27.752]  length: 2 (resolved future 2)
[01:29:27.752] resolved() for 'SequentialFuture' ...
[01:29:27.752] - state: 'finished'
[01:29:27.752] - run: TRUE
[01:29:27.753] - result: 'FutureResult'
[01:29:27.753] resolved() for 'SequentialFuture' ... done
[01:29:27.753] Future #3
[01:29:27.753] signalConditionsASAP(SequentialFuture, pos=3) ...
[01:29:27.753] - nx: 4
[01:29:27.753] - relay: TRUE
[01:29:27.754] - stdout: TRUE
[01:29:27.754] - signal: TRUE
[01:29:27.754] - resignal: FALSE
[01:29:27.754] - force: TRUE
[01:29:27.754] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:27.754] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:27.755]  - until=3
[01:29:27.755]  - relaying element #3
[01:29:27.755] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:27.755] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:27.755] signalConditionsASAP(SequentialFuture, pos=3) ... done
[01:29:27.756]  length: 1 (resolved future 3)
[01:29:27.756] resolved() for 'SequentialFuture' ...
[01:29:27.757] - state: 'finished'
[01:29:27.757] - run: TRUE
[01:29:27.757] - result: 'FutureResult'
[01:29:27.757] resolved() for 'SequentialFuture' ... done
[01:29:27.758] Future #4
[01:29:27.758] signalConditionsASAP(SequentialFuture, pos=4) ...
[01:29:27.758] - nx: 4
[01:29:27.758] - relay: TRUE
[01:29:27.758] - stdout: TRUE
[01:29:27.759] - signal: TRUE
[01:29:27.759] - resignal: FALSE
[01:29:27.759] - force: TRUE
[01:29:27.759] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:27.759] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:27.759]  - until=4
[01:29:27.759]  - relaying element #4
[01:29:27.760] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.760] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.760] signalConditionsASAP(SequentialFuture, pos=4) ... done
[01:29:27.760]  length: 0 (resolved future 4)
[01:29:27.760] Relaying remaining futures
[01:29:27.761] signalConditionsASAP(NULL, pos=0) ...
[01:29:27.761] - nx: 4
[01:29:27.761] - relay: TRUE
[01:29:27.761] - stdout: TRUE
[01:29:27.761] - signal: TRUE
[01:29:27.761] - resignal: FALSE
[01:29:27.761] - force: TRUE
[01:29:27.762] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.762] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[01:29:27.762] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.762] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:27.762] signalConditionsASAP(NULL, pos=0) ... done
[01:29:27.762] resolve() on list ... DONE
[[1]]
[1] 0

[[2]]
[1] 0

[[3]]
[1] 3

[[4]]
[1] 3

[01:29:27.765] getGlobalsAndPackages() ...
[01:29:27.765] Searching for globals...
[01:29:27.766] - globals found: [3] '{', 'sample', 'x'
[01:29:27.766] Searching for globals ... DONE
[01:29:27.766] Resolving globals: FALSE
[01:29:27.767] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.767] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.768] - globals: [1] 'x'
[01:29:27.768] 
[01:29:27.768] getGlobalsAndPackages() ... DONE
[01:29:27.768] run() for 'Future' ...
[01:29:27.768] - state: 'created'
[01:29:27.769] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.769] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.769] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.769]   - Field: 'label'
[01:29:27.770]   - Field: 'local'
[01:29:27.770]   - Field: 'owner'
[01:29:27.770]   - Field: 'envir'
[01:29:27.770]   - Field: 'packages'
[01:29:27.770]   - Field: 'gc'
[01:29:27.770]   - Field: 'conditions'
[01:29:27.771]   - Field: 'expr'
[01:29:27.771]   - Field: 'uuid'
[01:29:27.771]   - Field: 'seed'
[01:29:27.771]   - Field: 'version'
[01:29:27.771]   - Field: 'result'
[01:29:27.772]   - Field: 'asynchronous'
[01:29:27.772]   - Field: 'calls'
[01:29:27.772]   - Field: 'globals'
[01:29:27.772]   - Field: 'stdout'
[01:29:27.772]   - Field: 'earlySignal'
[01:29:27.772]   - Field: 'lazy'
[01:29:27.773]   - Field: 'state'
[01:29:27.773] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.773] - Launch lazy future ...
[01:29:27.773] Packages needed by the future expression (n = 0): <none>
[01:29:27.773] Packages needed by future strategies (n = 0): <none>
[01:29:27.774] {
[01:29:27.774]     {
[01:29:27.774]         {
[01:29:27.774]             ...future.startTime <- base::Sys.time()
[01:29:27.774]             {
[01:29:27.774]                 {
[01:29:27.774]                   {
[01:29:27.774]                     {
[01:29:27.774]                       base::local({
[01:29:27.774]                         has_future <- base::requireNamespace("future", 
[01:29:27.774]                           quietly = TRUE)
[01:29:27.774]                         if (has_future) {
[01:29:27.774]                           ns <- base::getNamespace("future")
[01:29:27.774]                           version <- ns[[".package"]][["version"]]
[01:29:27.774]                           if (is.null(version)) 
[01:29:27.774]                             version <- utils::packageVersion("future")
[01:29:27.774]                         }
[01:29:27.774]                         else {
[01:29:27.774]                           version <- NULL
[01:29:27.774]                         }
[01:29:27.774]                         if (!has_future || version < "1.8.0") {
[01:29:27.774]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.774]                             "", base::R.version$version.string), 
[01:29:27.774]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:27.774]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.774]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.774]                               "release", "version")], collapse = " "), 
[01:29:27.774]                             hostname = base::Sys.info()[["nodename"]])
[01:29:27.774]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.774]                             info)
[01:29:27.774]                           info <- base::paste(info, collapse = "; ")
[01:29:27.774]                           if (!has_future) {
[01:29:27.774]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.774]                               info)
[01:29:27.774]                           }
[01:29:27.774]                           else {
[01:29:27.774]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.774]                               info, version)
[01:29:27.774]                           }
[01:29:27.774]                           base::stop(msg)
[01:29:27.774]                         }
[01:29:27.774]                       })
[01:29:27.774]                     }
[01:29:27.774]                     options(future.plan = NULL)
[01:29:27.774]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.774]                     future::plan("default", .cleanup = FALSE, 
[01:29:27.774]                       .init = FALSE)
[01:29:27.774]                   }
[01:29:27.774]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[01:29:27.774]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[01:29:27.774]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[01:29:27.774]                 }
[01:29:27.774]                 ...future.workdir <- getwd()
[01:29:27.774]             }
[01:29:27.774]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.774]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.774]         }
[01:29:27.774]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.774]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.774]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.774]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.774]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.774]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.774]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.774]             base::names(...future.oldOptions))
[01:29:27.774]     }
[01:29:27.774]     if (FALSE) {
[01:29:27.774]     }
[01:29:27.774]     else {
[01:29:27.774]         if (TRUE) {
[01:29:27.774]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.774]                 open = "w")
[01:29:27.774]         }
[01:29:27.774]         else {
[01:29:27.774]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.774]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.774]         }
[01:29:27.774]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.774]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.774]             base::sink(type = "output", split = FALSE)
[01:29:27.774]             base::close(...future.stdout)
[01:29:27.774]         }, add = TRUE)
[01:29:27.774]     }
[01:29:27.774]     ...future.frame <- base::sys.nframe()
[01:29:27.774]     ...future.conditions <- base::list()
[01:29:27.774]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.774]     if (FALSE) {
[01:29:27.774]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.774]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.774]     }
[01:29:27.774]     ...future.result <- base::tryCatch({
[01:29:27.774]         base::withCallingHandlers({
[01:29:27.774]             ...future.value <- base::withVisible(base::local({
[01:29:27.774]                 sample(x, size = 1L)
[01:29:27.774]             }))
[01:29:27.774]             future::FutureResult(value = ...future.value$value, 
[01:29:27.774]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.774]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.774]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.774]                     ...future.globalenv.names))
[01:29:27.774]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.774]         }, condition = base::local({
[01:29:27.774]             c <- base::c
[01:29:27.774]             inherits <- base::inherits
[01:29:27.774]             invokeRestart <- base::invokeRestart
[01:29:27.774]             length <- base::length
[01:29:27.774]             list <- base::list
[01:29:27.774]             seq.int <- base::seq.int
[01:29:27.774]             signalCondition <- base::signalCondition
[01:29:27.774]             sys.calls <- base::sys.calls
[01:29:27.774]             `[[` <- base::`[[`
[01:29:27.774]             `+` <- base::`+`
[01:29:27.774]             `<<-` <- base::`<<-`
[01:29:27.774]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.774]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.774]                   3L)]
[01:29:27.774]             }
[01:29:27.774]             function(cond) {
[01:29:27.774]                 is_error <- inherits(cond, "error")
[01:29:27.774]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.774]                   NULL)
[01:29:27.774]                 if (is_error) {
[01:29:27.774]                   sessionInformation <- function() {
[01:29:27.774]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.774]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.774]                       search = base::search(), system = base::Sys.info())
[01:29:27.774]                   }
[01:29:27.774]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.774]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.774]                     cond$call), session = sessionInformation(), 
[01:29:27.774]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.774]                   signalCondition(cond)
[01:29:27.774]                 }
[01:29:27.774]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.774]                 "immediateCondition"))) {
[01:29:27.774]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.774]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.774]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.774]                   if (TRUE && !signal) {
[01:29:27.774]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.774]                     {
[01:29:27.774]                       inherits <- base::inherits
[01:29:27.774]                       invokeRestart <- base::invokeRestart
[01:29:27.774]                       is.null <- base::is.null
[01:29:27.774]                       muffled <- FALSE
[01:29:27.774]                       if (inherits(cond, "message")) {
[01:29:27.774]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.774]                         if (muffled) 
[01:29:27.774]                           invokeRestart("muffleMessage")
[01:29:27.774]                       }
[01:29:27.774]                       else if (inherits(cond, "warning")) {
[01:29:27.774]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.774]                         if (muffled) 
[01:29:27.774]                           invokeRestart("muffleWarning")
[01:29:27.774]                       }
[01:29:27.774]                       else if (inherits(cond, "condition")) {
[01:29:27.774]                         if (!is.null(pattern)) {
[01:29:27.774]                           computeRestarts <- base::computeRestarts
[01:29:27.774]                           grepl <- base::grepl
[01:29:27.774]                           restarts <- computeRestarts(cond)
[01:29:27.774]                           for (restart in restarts) {
[01:29:27.774]                             name <- restart$name
[01:29:27.774]                             if (is.null(name)) 
[01:29:27.774]                               next
[01:29:27.774]                             if (!grepl(pattern, name)) 
[01:29:27.774]                               next
[01:29:27.774]                             invokeRestart(restart)
[01:29:27.774]                             muffled <- TRUE
[01:29:27.774]                             break
[01:29:27.774]                           }
[01:29:27.774]                         }
[01:29:27.774]                       }
[01:29:27.774]                       invisible(muffled)
[01:29:27.774]                     }
[01:29:27.774]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.774]                   }
[01:29:27.774]                 }
[01:29:27.774]                 else {
[01:29:27.774]                   if (TRUE) {
[01:29:27.774]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.774]                     {
[01:29:27.774]                       inherits <- base::inherits
[01:29:27.774]                       invokeRestart <- base::invokeRestart
[01:29:27.774]                       is.null <- base::is.null
[01:29:27.774]                       muffled <- FALSE
[01:29:27.774]                       if (inherits(cond, "message")) {
[01:29:27.774]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.774]                         if (muffled) 
[01:29:27.774]                           invokeRestart("muffleMessage")
[01:29:27.774]                       }
[01:29:27.774]                       else if (inherits(cond, "warning")) {
[01:29:27.774]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.774]                         if (muffled) 
[01:29:27.774]                           invokeRestart("muffleWarning")
[01:29:27.774]                       }
[01:29:27.774]                       else if (inherits(cond, "condition")) {
[01:29:27.774]                         if (!is.null(pattern)) {
[01:29:27.774]                           computeRestarts <- base::computeRestarts
[01:29:27.774]                           grepl <- base::grepl
[01:29:27.774]                           restarts <- computeRestarts(cond)
[01:29:27.774]                           for (restart in restarts) {
[01:29:27.774]                             name <- restart$name
[01:29:27.774]                             if (is.null(name)) 
[01:29:27.774]                               next
[01:29:27.774]                             if (!grepl(pattern, name)) 
[01:29:27.774]                               next
[01:29:27.774]                             invokeRestart(restart)
[01:29:27.774]                             muffled <- TRUE
[01:29:27.774]                             break
[01:29:27.774]                           }
[01:29:27.774]                         }
[01:29:27.774]                       }
[01:29:27.774]                       invisible(muffled)
[01:29:27.774]                     }
[01:29:27.774]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.774]                   }
[01:29:27.774]                 }
[01:29:27.774]             }
[01:29:27.774]         }))
[01:29:27.774]     }, error = function(ex) {
[01:29:27.774]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.774]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.774]                 ...future.rng), started = ...future.startTime, 
[01:29:27.774]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.774]             version = "1.8"), class = "FutureResult")
[01:29:27.774]     }, finally = {
[01:29:27.774]         if (!identical(...future.workdir, getwd())) 
[01:29:27.774]             setwd(...future.workdir)
[01:29:27.774]         {
[01:29:27.774]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.774]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.774]             }
[01:29:27.774]             base::options(...future.oldOptions)
[01:29:27.774]             if (.Platform$OS.type == "windows") {
[01:29:27.774]                 old_names <- names(...future.oldEnvVars)
[01:29:27.774]                 envs <- base::Sys.getenv()
[01:29:27.774]                 names <- names(envs)
[01:29:27.774]                 common <- intersect(names, old_names)
[01:29:27.774]                 added <- setdiff(names, old_names)
[01:29:27.774]                 removed <- setdiff(old_names, names)
[01:29:27.774]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.774]                   envs[common]]
[01:29:27.774]                 NAMES <- toupper(changed)
[01:29:27.774]                 args <- list()
[01:29:27.774]                 for (kk in seq_along(NAMES)) {
[01:29:27.774]                   name <- changed[[kk]]
[01:29:27.774]                   NAME <- NAMES[[kk]]
[01:29:27.774]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.774]                     next
[01:29:27.774]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.774]                 }
[01:29:27.774]                 NAMES <- toupper(added)
[01:29:27.774]                 for (kk in seq_along(NAMES)) {
[01:29:27.774]                   name <- added[[kk]]
[01:29:27.774]                   NAME <- NAMES[[kk]]
[01:29:27.774]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.774]                     next
[01:29:27.774]                   args[[name]] <- ""
[01:29:27.774]                 }
[01:29:27.774]                 NAMES <- toupper(removed)
[01:29:27.774]                 for (kk in seq_along(NAMES)) {
[01:29:27.774]                   name <- removed[[kk]]
[01:29:27.774]                   NAME <- NAMES[[kk]]
[01:29:27.774]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.774]                     next
[01:29:27.774]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.774]                 }
[01:29:27.774]                 if (length(args) > 0) 
[01:29:27.774]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.774]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.774]             }
[01:29:27.774]             else {
[01:29:27.774]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.774]             }
[01:29:27.774]             {
[01:29:27.774]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.774]                   0L) {
[01:29:27.774]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.774]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.774]                   base::options(opts)
[01:29:27.774]                 }
[01:29:27.774]                 {
[01:29:27.774]                   {
[01:29:27.774]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:27.774]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:27.774]                     -1344458670L), envir = base::globalenv(), 
[01:29:27.774]                       inherits = FALSE)
[01:29:27.774]                     NULL
[01:29:27.774]                   }
[01:29:27.774]                   options(future.plan = NULL)
[01:29:27.774]                   if (is.na(NA_character_)) 
[01:29:27.774]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.774]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.774]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.774]                   {
[01:29:27.774]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.774]                     if (!future$lazy) 
[01:29:27.774]                       future <- run(future)
[01:29:27.774]                     invisible(future)
[01:29:27.774]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.774]                 }
[01:29:27.774]             }
[01:29:27.774]         }
[01:29:27.774]     })
[01:29:27.774]     if (TRUE) {
[01:29:27.774]         base::sink(type = "output", split = FALSE)
[01:29:27.774]         if (TRUE) {
[01:29:27.774]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.774]         }
[01:29:27.774]         else {
[01:29:27.774]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.774]         }
[01:29:27.774]         base::close(...future.stdout)
[01:29:27.774]         ...future.stdout <- NULL
[01:29:27.774]     }
[01:29:27.774]     ...future.result$conditions <- ...future.conditions
[01:29:27.774]     ...future.result$finished <- base::Sys.time()
[01:29:27.774]     ...future.result
[01:29:27.774] }
[01:29:27.778] assign_globals() ...
[01:29:27.778] List of 1
[01:29:27.778]  $ x: int [1:4] 0 1 2 3
[01:29:27.778]  - attr(*, "where")=List of 1
[01:29:27.778]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.778]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.778]  - attr(*, "resolved")= logi FALSE
[01:29:27.778]  - attr(*, "total_size")= num 64
[01:29:27.778]  - attr(*, "already-done")= logi TRUE
[01:29:27.781] - copied 'x' to environment
[01:29:27.781] assign_globals() ... done
[01:29:27.781] plan(): Setting new future strategy stack:
[01:29:27.782] List of future strategies:
[01:29:27.782] 1. sequential:
[01:29:27.782]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.782]    - tweaked: FALSE
[01:29:27.782]    - call: NULL
[01:29:27.782] plan(): nbrOfWorkers() = 1
[01:29:27.783] plan(): Setting new future strategy stack:
[01:29:27.784] List of future strategies:
[01:29:27.784] 1. sequential:
[01:29:27.784]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.784]    - tweaked: FALSE
[01:29:27.784]    - call: plan(strategy)
[01:29:27.784] plan(): nbrOfWorkers() = 1
[01:29:27.785] SequentialFuture started (and completed)
[01:29:27.785] - Launch lazy future ... done
[01:29:27.785] run() for 'SequentialFuture' ... done
[01:29:27.786] getGlobalsAndPackages() ...
[01:29:27.786] Searching for globals...
[01:29:27.788] - globals found: [3] '{', 'sample', 'x'
[01:29:27.788] Searching for globals ... DONE
[01:29:27.789] Resolving globals: FALSE
[01:29:27.789] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.790] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.790] - globals: [1] 'x'
[01:29:27.791] 
[01:29:27.791] getGlobalsAndPackages() ... DONE
[01:29:27.791] run() for 'Future' ...
[01:29:27.794] - state: 'created'
[01:29:27.794] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.795] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.795] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.796]   - Field: 'label'
[01:29:27.796]   - Field: 'local'
[01:29:27.796]   - Field: 'owner'
[01:29:27.796]   - Field: 'envir'
[01:29:27.797]   - Field: 'packages'
[01:29:27.797]   - Field: 'gc'
[01:29:27.797]   - Field: 'conditions'
[01:29:27.798]   - Field: 'expr'
[01:29:27.798]   - Field: 'uuid'
[01:29:27.798]   - Field: 'seed'
[01:29:27.798]   - Field: 'version'
[01:29:27.799]   - Field: 'result'
[01:29:27.799]   - Field: 'asynchronous'
[01:29:27.799]   - Field: 'calls'
[01:29:27.800]   - Field: 'globals'
[01:29:27.800]   - Field: 'stdout'
[01:29:27.800]   - Field: 'earlySignal'
[01:29:27.801]   - Field: 'lazy'
[01:29:27.801]   - Field: 'state'
[01:29:27.801] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.802] - Launch lazy future ...
[01:29:27.802] Packages needed by the future expression (n = 0): <none>
[01:29:27.802] Packages needed by future strategies (n = 0): <none>
[01:29:27.803] {
[01:29:27.803]     {
[01:29:27.803]         {
[01:29:27.803]             ...future.startTime <- base::Sys.time()
[01:29:27.803]             {
[01:29:27.803]                 {
[01:29:27.803]                   {
[01:29:27.803]                     {
[01:29:27.803]                       base::local({
[01:29:27.803]                         has_future <- base::requireNamespace("future", 
[01:29:27.803]                           quietly = TRUE)
[01:29:27.803]                         if (has_future) {
[01:29:27.803]                           ns <- base::getNamespace("future")
[01:29:27.803]                           version <- ns[[".package"]][["version"]]
[01:29:27.803]                           if (is.null(version)) 
[01:29:27.803]                             version <- utils::packageVersion("future")
[01:29:27.803]                         }
[01:29:27.803]                         else {
[01:29:27.803]                           version <- NULL
[01:29:27.803]                         }
[01:29:27.803]                         if (!has_future || version < "1.8.0") {
[01:29:27.803]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.803]                             "", base::R.version$version.string), 
[01:29:27.803]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:27.803]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.803]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.803]                               "release", "version")], collapse = " "), 
[01:29:27.803]                             hostname = base::Sys.info()[["nodename"]])
[01:29:27.803]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.803]                             info)
[01:29:27.803]                           info <- base::paste(info, collapse = "; ")
[01:29:27.803]                           if (!has_future) {
[01:29:27.803]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.803]                               info)
[01:29:27.803]                           }
[01:29:27.803]                           else {
[01:29:27.803]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.803]                               info, version)
[01:29:27.803]                           }
[01:29:27.803]                           base::stop(msg)
[01:29:27.803]                         }
[01:29:27.803]                       })
[01:29:27.803]                     }
[01:29:27.803]                     options(future.plan = NULL)
[01:29:27.803]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.803]                     future::plan("default", .cleanup = FALSE, 
[01:29:27.803]                       .init = FALSE)
[01:29:27.803]                   }
[01:29:27.803]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[01:29:27.803]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[01:29:27.803]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[01:29:27.803]                 }
[01:29:27.803]                 ...future.workdir <- getwd()
[01:29:27.803]             }
[01:29:27.803]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.803]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.803]         }
[01:29:27.803]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.803]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.803]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.803]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.803]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.803]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.803]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.803]             base::names(...future.oldOptions))
[01:29:27.803]     }
[01:29:27.803]     if (FALSE) {
[01:29:27.803]     }
[01:29:27.803]     else {
[01:29:27.803]         if (TRUE) {
[01:29:27.803]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.803]                 open = "w")
[01:29:27.803]         }
[01:29:27.803]         else {
[01:29:27.803]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.803]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.803]         }
[01:29:27.803]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.803]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.803]             base::sink(type = "output", split = FALSE)
[01:29:27.803]             base::close(...future.stdout)
[01:29:27.803]         }, add = TRUE)
[01:29:27.803]     }
[01:29:27.803]     ...future.frame <- base::sys.nframe()
[01:29:27.803]     ...future.conditions <- base::list()
[01:29:27.803]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.803]     if (FALSE) {
[01:29:27.803]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.803]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.803]     }
[01:29:27.803]     ...future.result <- base::tryCatch({
[01:29:27.803]         base::withCallingHandlers({
[01:29:27.803]             ...future.value <- base::withVisible(base::local({
[01:29:27.803]                 sample(x, size = 1L)
[01:29:27.803]             }))
[01:29:27.803]             future::FutureResult(value = ...future.value$value, 
[01:29:27.803]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.803]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.803]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.803]                     ...future.globalenv.names))
[01:29:27.803]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.803]         }, condition = base::local({
[01:29:27.803]             c <- base::c
[01:29:27.803]             inherits <- base::inherits
[01:29:27.803]             invokeRestart <- base::invokeRestart
[01:29:27.803]             length <- base::length
[01:29:27.803]             list <- base::list
[01:29:27.803]             seq.int <- base::seq.int
[01:29:27.803]             signalCondition <- base::signalCondition
[01:29:27.803]             sys.calls <- base::sys.calls
[01:29:27.803]             `[[` <- base::`[[`
[01:29:27.803]             `+` <- base::`+`
[01:29:27.803]             `<<-` <- base::`<<-`
[01:29:27.803]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.803]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.803]                   3L)]
[01:29:27.803]             }
[01:29:27.803]             function(cond) {
[01:29:27.803]                 is_error <- inherits(cond, "error")
[01:29:27.803]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.803]                   NULL)
[01:29:27.803]                 if (is_error) {
[01:29:27.803]                   sessionInformation <- function() {
[01:29:27.803]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.803]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.803]                       search = base::search(), system = base::Sys.info())
[01:29:27.803]                   }
[01:29:27.803]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.803]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.803]                     cond$call), session = sessionInformation(), 
[01:29:27.803]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.803]                   signalCondition(cond)
[01:29:27.803]                 }
[01:29:27.803]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.803]                 "immediateCondition"))) {
[01:29:27.803]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.803]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.803]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.803]                   if (TRUE && !signal) {
[01:29:27.803]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.803]                     {
[01:29:27.803]                       inherits <- base::inherits
[01:29:27.803]                       invokeRestart <- base::invokeRestart
[01:29:27.803]                       is.null <- base::is.null
[01:29:27.803]                       muffled <- FALSE
[01:29:27.803]                       if (inherits(cond, "message")) {
[01:29:27.803]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.803]                         if (muffled) 
[01:29:27.803]                           invokeRestart("muffleMessage")
[01:29:27.803]                       }
[01:29:27.803]                       else if (inherits(cond, "warning")) {
[01:29:27.803]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.803]                         if (muffled) 
[01:29:27.803]                           invokeRestart("muffleWarning")
[01:29:27.803]                       }
[01:29:27.803]                       else if (inherits(cond, "condition")) {
[01:29:27.803]                         if (!is.null(pattern)) {
[01:29:27.803]                           computeRestarts <- base::computeRestarts
[01:29:27.803]                           grepl <- base::grepl
[01:29:27.803]                           restarts <- computeRestarts(cond)
[01:29:27.803]                           for (restart in restarts) {
[01:29:27.803]                             name <- restart$name
[01:29:27.803]                             if (is.null(name)) 
[01:29:27.803]                               next
[01:29:27.803]                             if (!grepl(pattern, name)) 
[01:29:27.803]                               next
[01:29:27.803]                             invokeRestart(restart)
[01:29:27.803]                             muffled <- TRUE
[01:29:27.803]                             break
[01:29:27.803]                           }
[01:29:27.803]                         }
[01:29:27.803]                       }
[01:29:27.803]                       invisible(muffled)
[01:29:27.803]                     }
[01:29:27.803]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.803]                   }
[01:29:27.803]                 }
[01:29:27.803]                 else {
[01:29:27.803]                   if (TRUE) {
[01:29:27.803]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.803]                     {
[01:29:27.803]                       inherits <- base::inherits
[01:29:27.803]                       invokeRestart <- base::invokeRestart
[01:29:27.803]                       is.null <- base::is.null
[01:29:27.803]                       muffled <- FALSE
[01:29:27.803]                       if (inherits(cond, "message")) {
[01:29:27.803]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.803]                         if (muffled) 
[01:29:27.803]                           invokeRestart("muffleMessage")
[01:29:27.803]                       }
[01:29:27.803]                       else if (inherits(cond, "warning")) {
[01:29:27.803]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.803]                         if (muffled) 
[01:29:27.803]                           invokeRestart("muffleWarning")
[01:29:27.803]                       }
[01:29:27.803]                       else if (inherits(cond, "condition")) {
[01:29:27.803]                         if (!is.null(pattern)) {
[01:29:27.803]                           computeRestarts <- base::computeRestarts
[01:29:27.803]                           grepl <- base::grepl
[01:29:27.803]                           restarts <- computeRestarts(cond)
[01:29:27.803]                           for (restart in restarts) {
[01:29:27.803]                             name <- restart$name
[01:29:27.803]                             if (is.null(name)) 
[01:29:27.803]                               next
[01:29:27.803]                             if (!grepl(pattern, name)) 
[01:29:27.803]                               next
[01:29:27.803]                             invokeRestart(restart)
[01:29:27.803]                             muffled <- TRUE
[01:29:27.803]                             break
[01:29:27.803]                           }
[01:29:27.803]                         }
[01:29:27.803]                       }
[01:29:27.803]                       invisible(muffled)
[01:29:27.803]                     }
[01:29:27.803]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.803]                   }
[01:29:27.803]                 }
[01:29:27.803]             }
[01:29:27.803]         }))
[01:29:27.803]     }, error = function(ex) {
[01:29:27.803]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.803]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.803]                 ...future.rng), started = ...future.startTime, 
[01:29:27.803]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.803]             version = "1.8"), class = "FutureResult")
[01:29:27.803]     }, finally = {
[01:29:27.803]         if (!identical(...future.workdir, getwd())) 
[01:29:27.803]             setwd(...future.workdir)
[01:29:27.803]         {
[01:29:27.803]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.803]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.803]             }
[01:29:27.803]             base::options(...future.oldOptions)
[01:29:27.803]             if (.Platform$OS.type == "windows") {
[01:29:27.803]                 old_names <- names(...future.oldEnvVars)
[01:29:27.803]                 envs <- base::Sys.getenv()
[01:29:27.803]                 names <- names(envs)
[01:29:27.803]                 common <- intersect(names, old_names)
[01:29:27.803]                 added <- setdiff(names, old_names)
[01:29:27.803]                 removed <- setdiff(old_names, names)
[01:29:27.803]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.803]                   envs[common]]
[01:29:27.803]                 NAMES <- toupper(changed)
[01:29:27.803]                 args <- list()
[01:29:27.803]                 for (kk in seq_along(NAMES)) {
[01:29:27.803]                   name <- changed[[kk]]
[01:29:27.803]                   NAME <- NAMES[[kk]]
[01:29:27.803]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.803]                     next
[01:29:27.803]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.803]                 }
[01:29:27.803]                 NAMES <- toupper(added)
[01:29:27.803]                 for (kk in seq_along(NAMES)) {
[01:29:27.803]                   name <- added[[kk]]
[01:29:27.803]                   NAME <- NAMES[[kk]]
[01:29:27.803]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.803]                     next
[01:29:27.803]                   args[[name]] <- ""
[01:29:27.803]                 }
[01:29:27.803]                 NAMES <- toupper(removed)
[01:29:27.803]                 for (kk in seq_along(NAMES)) {
[01:29:27.803]                   name <- removed[[kk]]
[01:29:27.803]                   NAME <- NAMES[[kk]]
[01:29:27.803]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.803]                     next
[01:29:27.803]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.803]                 }
[01:29:27.803]                 if (length(args) > 0) 
[01:29:27.803]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.803]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.803]             }
[01:29:27.803]             else {
[01:29:27.803]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.803]             }
[01:29:27.803]             {
[01:29:27.803]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.803]                   0L) {
[01:29:27.803]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.803]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.803]                   base::options(opts)
[01:29:27.803]                 }
[01:29:27.803]                 {
[01:29:27.803]                   {
[01:29:27.803]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:27.803]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:27.803]                     -1344458670L), envir = base::globalenv(), 
[01:29:27.803]                       inherits = FALSE)
[01:29:27.803]                     NULL
[01:29:27.803]                   }
[01:29:27.803]                   options(future.plan = NULL)
[01:29:27.803]                   if (is.na(NA_character_)) 
[01:29:27.803]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.803]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.803]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.803]                   {
[01:29:27.803]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.803]                     if (!future$lazy) 
[01:29:27.803]                       future <- run(future)
[01:29:27.803]                     invisible(future)
[01:29:27.803]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.803]                 }
[01:29:27.803]             }
[01:29:27.803]         }
[01:29:27.803]     })
[01:29:27.803]     if (TRUE) {
[01:29:27.803]         base::sink(type = "output", split = FALSE)
[01:29:27.803]         if (TRUE) {
[01:29:27.803]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.803]         }
[01:29:27.803]         else {
[01:29:27.803]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.803]         }
[01:29:27.803]         base::close(...future.stdout)
[01:29:27.803]         ...future.stdout <- NULL
[01:29:27.803]     }
[01:29:27.803]     ...future.result$conditions <- ...future.conditions
[01:29:27.803]     ...future.result$finished <- base::Sys.time()
[01:29:27.803]     ...future.result
[01:29:27.803] }
[01:29:27.809] assign_globals() ...
[01:29:27.809] List of 1
[01:29:27.809]  $ x: int [1:4] 0 1 2 3
[01:29:27.809]  - attr(*, "where")=List of 1
[01:29:27.809]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.809]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.809]  - attr(*, "resolved")= logi FALSE
[01:29:27.809]  - attr(*, "total_size")= num 64
[01:29:27.809]  - attr(*, "already-done")= logi TRUE
[01:29:27.815] - copied 'x' to environment
[01:29:27.815] assign_globals() ... done
[01:29:27.815] plan(): Setting new future strategy stack:
[01:29:27.816] List of future strategies:
[01:29:27.816] 1. sequential:
[01:29:27.816]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.816]    - tweaked: FALSE
[01:29:27.816]    - call: NULL
[01:29:27.817] plan(): nbrOfWorkers() = 1
[01:29:27.819] plan(): Setting new future strategy stack:
[01:29:27.819] List of future strategies:
[01:29:27.819] 1. sequential:
[01:29:27.819]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.819]    - tweaked: FALSE
[01:29:27.819]    - call: plan(strategy)
[01:29:27.820] plan(): nbrOfWorkers() = 1
[01:29:27.820] SequentialFuture started (and completed)
[01:29:27.821] - Launch lazy future ... done
[01:29:27.821] run() for 'SequentialFuture' ... done
[01:29:27.822] getGlobalsAndPackages() ...
[01:29:27.822] Searching for globals...
[01:29:27.824] - globals found: [3] '{', 'sample', 'x'
[01:29:27.825] Searching for globals ... DONE
[01:29:27.825] Resolving globals: FALSE
[01:29:27.826] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.826] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.827] - globals: [1] 'x'
[01:29:27.827] 
[01:29:27.827] getGlobalsAndPackages() ... DONE
[01:29:27.828] run() for 'Future' ...
[01:29:27.828] - state: 'created'
[01:29:27.829] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.829] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.830] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.830]   - Field: 'label'
[01:29:27.830]   - Field: 'local'
[01:29:27.831]   - Field: 'owner'
[01:29:27.831]   - Field: 'envir'
[01:29:27.831]   - Field: 'packages'
[01:29:27.832]   - Field: 'gc'
[01:29:27.832]   - Field: 'conditions'
[01:29:27.832]   - Field: 'expr'
[01:29:27.832]   - Field: 'uuid'
[01:29:27.833]   - Field: 'seed'
[01:29:27.833]   - Field: 'version'
[01:29:27.833]   - Field: 'result'
[01:29:27.834]   - Field: 'asynchronous'
[01:29:27.834]   - Field: 'calls'
[01:29:27.834]   - Field: 'globals'
[01:29:27.835]   - Field: 'stdout'
[01:29:27.835]   - Field: 'earlySignal'
[01:29:27.835]   - Field: 'lazy'
[01:29:27.836]   - Field: 'state'
[01:29:27.836] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.836] - Launch lazy future ...
[01:29:27.837] Packages needed by the future expression (n = 0): <none>
[01:29:27.837] Packages needed by future strategies (n = 0): <none>
[01:29:27.838] {
[01:29:27.838]     {
[01:29:27.838]         {
[01:29:27.838]             ...future.startTime <- base::Sys.time()
[01:29:27.838]             {
[01:29:27.838]                 {
[01:29:27.838]                   {
[01:29:27.838]                     {
[01:29:27.838]                       base::local({
[01:29:27.838]                         has_future <- base::requireNamespace("future", 
[01:29:27.838]                           quietly = TRUE)
[01:29:27.838]                         if (has_future) {
[01:29:27.838]                           ns <- base::getNamespace("future")
[01:29:27.838]                           version <- ns[[".package"]][["version"]]
[01:29:27.838]                           if (is.null(version)) 
[01:29:27.838]                             version <- utils::packageVersion("future")
[01:29:27.838]                         }
[01:29:27.838]                         else {
[01:29:27.838]                           version <- NULL
[01:29:27.838]                         }
[01:29:27.838]                         if (!has_future || version < "1.8.0") {
[01:29:27.838]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.838]                             "", base::R.version$version.string), 
[01:29:27.838]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:27.838]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.838]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.838]                               "release", "version")], collapse = " "), 
[01:29:27.838]                             hostname = base::Sys.info()[["nodename"]])
[01:29:27.838]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.838]                             info)
[01:29:27.838]                           info <- base::paste(info, collapse = "; ")
[01:29:27.838]                           if (!has_future) {
[01:29:27.838]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.838]                               info)
[01:29:27.838]                           }
[01:29:27.838]                           else {
[01:29:27.838]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.838]                               info, version)
[01:29:27.838]                           }
[01:29:27.838]                           base::stop(msg)
[01:29:27.838]                         }
[01:29:27.838]                       })
[01:29:27.838]                     }
[01:29:27.838]                     options(future.plan = NULL)
[01:29:27.838]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.838]                     future::plan("default", .cleanup = FALSE, 
[01:29:27.838]                       .init = FALSE)
[01:29:27.838]                   }
[01:29:27.838]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[01:29:27.838]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[01:29:27.838]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[01:29:27.838]                 }
[01:29:27.838]                 ...future.workdir <- getwd()
[01:29:27.838]             }
[01:29:27.838]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.838]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.838]         }
[01:29:27.838]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.838]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.838]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.838]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.838]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.838]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.838]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.838]             base::names(...future.oldOptions))
[01:29:27.838]     }
[01:29:27.838]     if (FALSE) {
[01:29:27.838]     }
[01:29:27.838]     else {
[01:29:27.838]         if (TRUE) {
[01:29:27.838]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.838]                 open = "w")
[01:29:27.838]         }
[01:29:27.838]         else {
[01:29:27.838]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.838]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.838]         }
[01:29:27.838]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.838]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.838]             base::sink(type = "output", split = FALSE)
[01:29:27.838]             base::close(...future.stdout)
[01:29:27.838]         }, add = TRUE)
[01:29:27.838]     }
[01:29:27.838]     ...future.frame <- base::sys.nframe()
[01:29:27.838]     ...future.conditions <- base::list()
[01:29:27.838]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.838]     if (FALSE) {
[01:29:27.838]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.838]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.838]     }
[01:29:27.838]     ...future.result <- base::tryCatch({
[01:29:27.838]         base::withCallingHandlers({
[01:29:27.838]             ...future.value <- base::withVisible(base::local({
[01:29:27.838]                 sample(x, size = 1L)
[01:29:27.838]             }))
[01:29:27.838]             future::FutureResult(value = ...future.value$value, 
[01:29:27.838]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.838]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.838]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.838]                     ...future.globalenv.names))
[01:29:27.838]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.838]         }, condition = base::local({
[01:29:27.838]             c <- base::c
[01:29:27.838]             inherits <- base::inherits
[01:29:27.838]             invokeRestart <- base::invokeRestart
[01:29:27.838]             length <- base::length
[01:29:27.838]             list <- base::list
[01:29:27.838]             seq.int <- base::seq.int
[01:29:27.838]             signalCondition <- base::signalCondition
[01:29:27.838]             sys.calls <- base::sys.calls
[01:29:27.838]             `[[` <- base::`[[`
[01:29:27.838]             `+` <- base::`+`
[01:29:27.838]             `<<-` <- base::`<<-`
[01:29:27.838]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.838]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.838]                   3L)]
[01:29:27.838]             }
[01:29:27.838]             function(cond) {
[01:29:27.838]                 is_error <- inherits(cond, "error")
[01:29:27.838]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.838]                   NULL)
[01:29:27.838]                 if (is_error) {
[01:29:27.838]                   sessionInformation <- function() {
[01:29:27.838]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.838]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.838]                       search = base::search(), system = base::Sys.info())
[01:29:27.838]                   }
[01:29:27.838]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.838]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.838]                     cond$call), session = sessionInformation(), 
[01:29:27.838]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.838]                   signalCondition(cond)
[01:29:27.838]                 }
[01:29:27.838]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.838]                 "immediateCondition"))) {
[01:29:27.838]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.838]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.838]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.838]                   if (TRUE && !signal) {
[01:29:27.838]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.838]                     {
[01:29:27.838]                       inherits <- base::inherits
[01:29:27.838]                       invokeRestart <- base::invokeRestart
[01:29:27.838]                       is.null <- base::is.null
[01:29:27.838]                       muffled <- FALSE
[01:29:27.838]                       if (inherits(cond, "message")) {
[01:29:27.838]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.838]                         if (muffled) 
[01:29:27.838]                           invokeRestart("muffleMessage")
[01:29:27.838]                       }
[01:29:27.838]                       else if (inherits(cond, "warning")) {
[01:29:27.838]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.838]                         if (muffled) 
[01:29:27.838]                           invokeRestart("muffleWarning")
[01:29:27.838]                       }
[01:29:27.838]                       else if (inherits(cond, "condition")) {
[01:29:27.838]                         if (!is.null(pattern)) {
[01:29:27.838]                           computeRestarts <- base::computeRestarts
[01:29:27.838]                           grepl <- base::grepl
[01:29:27.838]                           restarts <- computeRestarts(cond)
[01:29:27.838]                           for (restart in restarts) {
[01:29:27.838]                             name <- restart$name
[01:29:27.838]                             if (is.null(name)) 
[01:29:27.838]                               next
[01:29:27.838]                             if (!grepl(pattern, name)) 
[01:29:27.838]                               next
[01:29:27.838]                             invokeRestart(restart)
[01:29:27.838]                             muffled <- TRUE
[01:29:27.838]                             break
[01:29:27.838]                           }
[01:29:27.838]                         }
[01:29:27.838]                       }
[01:29:27.838]                       invisible(muffled)
[01:29:27.838]                     }
[01:29:27.838]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.838]                   }
[01:29:27.838]                 }
[01:29:27.838]                 else {
[01:29:27.838]                   if (TRUE) {
[01:29:27.838]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.838]                     {
[01:29:27.838]                       inherits <- base::inherits
[01:29:27.838]                       invokeRestart <- base::invokeRestart
[01:29:27.838]                       is.null <- base::is.null
[01:29:27.838]                       muffled <- FALSE
[01:29:27.838]                       if (inherits(cond, "message")) {
[01:29:27.838]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.838]                         if (muffled) 
[01:29:27.838]                           invokeRestart("muffleMessage")
[01:29:27.838]                       }
[01:29:27.838]                       else if (inherits(cond, "warning")) {
[01:29:27.838]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.838]                         if (muffled) 
[01:29:27.838]                           invokeRestart("muffleWarning")
[01:29:27.838]                       }
[01:29:27.838]                       else if (inherits(cond, "condition")) {
[01:29:27.838]                         if (!is.null(pattern)) {
[01:29:27.838]                           computeRestarts <- base::computeRestarts
[01:29:27.838]                           grepl <- base::grepl
[01:29:27.838]                           restarts <- computeRestarts(cond)
[01:29:27.838]                           for (restart in restarts) {
[01:29:27.838]                             name <- restart$name
[01:29:27.838]                             if (is.null(name)) 
[01:29:27.838]                               next
[01:29:27.838]                             if (!grepl(pattern, name)) 
[01:29:27.838]                               next
[01:29:27.838]                             invokeRestart(restart)
[01:29:27.838]                             muffled <- TRUE
[01:29:27.838]                             break
[01:29:27.838]                           }
[01:29:27.838]                         }
[01:29:27.838]                       }
[01:29:27.838]                       invisible(muffled)
[01:29:27.838]                     }
[01:29:27.838]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.838]                   }
[01:29:27.838]                 }
[01:29:27.838]             }
[01:29:27.838]         }))
[01:29:27.838]     }, error = function(ex) {
[01:29:27.838]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.838]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.838]                 ...future.rng), started = ...future.startTime, 
[01:29:27.838]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.838]             version = "1.8"), class = "FutureResult")
[01:29:27.838]     }, finally = {
[01:29:27.838]         if (!identical(...future.workdir, getwd())) 
[01:29:27.838]             setwd(...future.workdir)
[01:29:27.838]         {
[01:29:27.838]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.838]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.838]             }
[01:29:27.838]             base::options(...future.oldOptions)
[01:29:27.838]             if (.Platform$OS.type == "windows") {
[01:29:27.838]                 old_names <- names(...future.oldEnvVars)
[01:29:27.838]                 envs <- base::Sys.getenv()
[01:29:27.838]                 names <- names(envs)
[01:29:27.838]                 common <- intersect(names, old_names)
[01:29:27.838]                 added <- setdiff(names, old_names)
[01:29:27.838]                 removed <- setdiff(old_names, names)
[01:29:27.838]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.838]                   envs[common]]
[01:29:27.838]                 NAMES <- toupper(changed)
[01:29:27.838]                 args <- list()
[01:29:27.838]                 for (kk in seq_along(NAMES)) {
[01:29:27.838]                   name <- changed[[kk]]
[01:29:27.838]                   NAME <- NAMES[[kk]]
[01:29:27.838]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.838]                     next
[01:29:27.838]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.838]                 }
[01:29:27.838]                 NAMES <- toupper(added)
[01:29:27.838]                 for (kk in seq_along(NAMES)) {
[01:29:27.838]                   name <- added[[kk]]
[01:29:27.838]                   NAME <- NAMES[[kk]]
[01:29:27.838]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.838]                     next
[01:29:27.838]                   args[[name]] <- ""
[01:29:27.838]                 }
[01:29:27.838]                 NAMES <- toupper(removed)
[01:29:27.838]                 for (kk in seq_along(NAMES)) {
[01:29:27.838]                   name <- removed[[kk]]
[01:29:27.838]                   NAME <- NAMES[[kk]]
[01:29:27.838]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.838]                     next
[01:29:27.838]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.838]                 }
[01:29:27.838]                 if (length(args) > 0) 
[01:29:27.838]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.838]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.838]             }
[01:29:27.838]             else {
[01:29:27.838]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.838]             }
[01:29:27.838]             {
[01:29:27.838]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.838]                   0L) {
[01:29:27.838]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.838]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.838]                   base::options(opts)
[01:29:27.838]                 }
[01:29:27.838]                 {
[01:29:27.838]                   {
[01:29:27.838]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:27.838]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:27.838]                     -1344458670L), envir = base::globalenv(), 
[01:29:27.838]                       inherits = FALSE)
[01:29:27.838]                     NULL
[01:29:27.838]                   }
[01:29:27.838]                   options(future.plan = NULL)
[01:29:27.838]                   if (is.na(NA_character_)) 
[01:29:27.838]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.838]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.838]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.838]                   {
[01:29:27.838]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.838]                     if (!future$lazy) 
[01:29:27.838]                       future <- run(future)
[01:29:27.838]                     invisible(future)
[01:29:27.838]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.838]                 }
[01:29:27.838]             }
[01:29:27.838]         }
[01:29:27.838]     })
[01:29:27.838]     if (TRUE) {
[01:29:27.838]         base::sink(type = "output", split = FALSE)
[01:29:27.838]         if (TRUE) {
[01:29:27.838]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.838]         }
[01:29:27.838]         else {
[01:29:27.838]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.838]         }
[01:29:27.838]         base::close(...future.stdout)
[01:29:27.838]         ...future.stdout <- NULL
[01:29:27.838]     }
[01:29:27.838]     ...future.result$conditions <- ...future.conditions
[01:29:27.838]     ...future.result$finished <- base::Sys.time()
[01:29:27.838]     ...future.result
[01:29:27.838] }
[01:29:27.844] assign_globals() ...
[01:29:27.844] List of 1
[01:29:27.844]  $ x: int [1:4] 0 1 2 3
[01:29:27.844]  - attr(*, "where")=List of 1
[01:29:27.844]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.844]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.844]  - attr(*, "resolved")= logi FALSE
[01:29:27.844]  - attr(*, "total_size")= num 64
[01:29:27.844]  - attr(*, "already-done")= logi TRUE
[01:29:27.850] - copied 'x' to environment
[01:29:27.853] assign_globals() ... done
[01:29:27.854] plan(): Setting new future strategy stack:
[01:29:27.854] List of future strategies:
[01:29:27.854] 1. sequential:
[01:29:27.854]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.854]    - tweaked: FALSE
[01:29:27.854]    - call: NULL
[01:29:27.855] plan(): nbrOfWorkers() = 1
[01:29:27.857] plan(): Setting new future strategy stack:
[01:29:27.857] List of future strategies:
[01:29:27.857] 1. sequential:
[01:29:27.857]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.857]    - tweaked: FALSE
[01:29:27.857]    - call: plan(strategy)
[01:29:27.858] plan(): nbrOfWorkers() = 1
[01:29:27.859] SequentialFuture started (and completed)
[01:29:27.859] - Launch lazy future ... done
[01:29:27.859] run() for 'SequentialFuture' ... done
[01:29:27.860] getGlobalsAndPackages() ...
[01:29:27.861] Searching for globals...
[01:29:27.863] - globals found: [3] '{', 'sample', 'x'
[01:29:27.864] Searching for globals ... DONE
[01:29:27.864] Resolving globals: FALSE
[01:29:27.865] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.865] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.866] - globals: [1] 'x'
[01:29:27.866] 
[01:29:27.866] getGlobalsAndPackages() ... DONE
[01:29:27.867] run() for 'Future' ...
[01:29:27.867] - state: 'created'
[01:29:27.867] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.868] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.868] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.869]   - Field: 'label'
[01:29:27.869]   - Field: 'local'
[01:29:27.869]   - Field: 'owner'
[01:29:27.869]   - Field: 'envir'
[01:29:27.870]   - Field: 'packages'
[01:29:27.870]   - Field: 'gc'
[01:29:27.870]   - Field: 'conditions'
[01:29:27.871]   - Field: 'expr'
[01:29:27.871]   - Field: 'uuid'
[01:29:27.871]   - Field: 'seed'
[01:29:27.872]   - Field: 'version'
[01:29:27.872]   - Field: 'result'
[01:29:27.872]   - Field: 'asynchronous'
[01:29:27.872]   - Field: 'calls'
[01:29:27.873]   - Field: 'globals'
[01:29:27.873]   - Field: 'stdout'
[01:29:27.873]   - Field: 'earlySignal'
[01:29:27.873]   - Field: 'lazy'
[01:29:27.874]   - Field: 'state'
[01:29:27.874] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.874] - Launch lazy future ...
[01:29:27.875] Packages needed by the future expression (n = 0): <none>
[01:29:27.875] Packages needed by future strategies (n = 0): <none>
[01:29:27.876] {
[01:29:27.876]     {
[01:29:27.876]         {
[01:29:27.876]             ...future.startTime <- base::Sys.time()
[01:29:27.876]             {
[01:29:27.876]                 {
[01:29:27.876]                   {
[01:29:27.876]                     {
[01:29:27.876]                       base::local({
[01:29:27.876]                         has_future <- base::requireNamespace("future", 
[01:29:27.876]                           quietly = TRUE)
[01:29:27.876]                         if (has_future) {
[01:29:27.876]                           ns <- base::getNamespace("future")
[01:29:27.876]                           version <- ns[[".package"]][["version"]]
[01:29:27.876]                           if (is.null(version)) 
[01:29:27.876]                             version <- utils::packageVersion("future")
[01:29:27.876]                         }
[01:29:27.876]                         else {
[01:29:27.876]                           version <- NULL
[01:29:27.876]                         }
[01:29:27.876]                         if (!has_future || version < "1.8.0") {
[01:29:27.876]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.876]                             "", base::R.version$version.string), 
[01:29:27.876]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:27.876]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.876]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.876]                               "release", "version")], collapse = " "), 
[01:29:27.876]                             hostname = base::Sys.info()[["nodename"]])
[01:29:27.876]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.876]                             info)
[01:29:27.876]                           info <- base::paste(info, collapse = "; ")
[01:29:27.876]                           if (!has_future) {
[01:29:27.876]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.876]                               info)
[01:29:27.876]                           }
[01:29:27.876]                           else {
[01:29:27.876]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.876]                               info, version)
[01:29:27.876]                           }
[01:29:27.876]                           base::stop(msg)
[01:29:27.876]                         }
[01:29:27.876]                       })
[01:29:27.876]                     }
[01:29:27.876]                     options(future.plan = NULL)
[01:29:27.876]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.876]                     future::plan("default", .cleanup = FALSE, 
[01:29:27.876]                       .init = FALSE)
[01:29:27.876]                   }
[01:29:27.876]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[01:29:27.876]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[01:29:27.876]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[01:29:27.876]                 }
[01:29:27.876]                 ...future.workdir <- getwd()
[01:29:27.876]             }
[01:29:27.876]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.876]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.876]         }
[01:29:27.876]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.876]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.876]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.876]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.876]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.876]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.876]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.876]             base::names(...future.oldOptions))
[01:29:27.876]     }
[01:29:27.876]     if (FALSE) {
[01:29:27.876]     }
[01:29:27.876]     else {
[01:29:27.876]         if (TRUE) {
[01:29:27.876]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.876]                 open = "w")
[01:29:27.876]         }
[01:29:27.876]         else {
[01:29:27.876]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.876]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.876]         }
[01:29:27.876]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.876]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.876]             base::sink(type = "output", split = FALSE)
[01:29:27.876]             base::close(...future.stdout)
[01:29:27.876]         }, add = TRUE)
[01:29:27.876]     }
[01:29:27.876]     ...future.frame <- base::sys.nframe()
[01:29:27.876]     ...future.conditions <- base::list()
[01:29:27.876]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.876]     if (FALSE) {
[01:29:27.876]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.876]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.876]     }
[01:29:27.876]     ...future.result <- base::tryCatch({
[01:29:27.876]         base::withCallingHandlers({
[01:29:27.876]             ...future.value <- base::withVisible(base::local({
[01:29:27.876]                 sample(x, size = 1L)
[01:29:27.876]             }))
[01:29:27.876]             future::FutureResult(value = ...future.value$value, 
[01:29:27.876]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.876]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.876]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.876]                     ...future.globalenv.names))
[01:29:27.876]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.876]         }, condition = base::local({
[01:29:27.876]             c <- base::c
[01:29:27.876]             inherits <- base::inherits
[01:29:27.876]             invokeRestart <- base::invokeRestart
[01:29:27.876]             length <- base::length
[01:29:27.876]             list <- base::list
[01:29:27.876]             seq.int <- base::seq.int
[01:29:27.876]             signalCondition <- base::signalCondition
[01:29:27.876]             sys.calls <- base::sys.calls
[01:29:27.876]             `[[` <- base::`[[`
[01:29:27.876]             `+` <- base::`+`
[01:29:27.876]             `<<-` <- base::`<<-`
[01:29:27.876]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.876]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.876]                   3L)]
[01:29:27.876]             }
[01:29:27.876]             function(cond) {
[01:29:27.876]                 is_error <- inherits(cond, "error")
[01:29:27.876]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.876]                   NULL)
[01:29:27.876]                 if (is_error) {
[01:29:27.876]                   sessionInformation <- function() {
[01:29:27.876]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.876]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.876]                       search = base::search(), system = base::Sys.info())
[01:29:27.876]                   }
[01:29:27.876]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.876]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.876]                     cond$call), session = sessionInformation(), 
[01:29:27.876]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.876]                   signalCondition(cond)
[01:29:27.876]                 }
[01:29:27.876]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.876]                 "immediateCondition"))) {
[01:29:27.876]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.876]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.876]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.876]                   if (TRUE && !signal) {
[01:29:27.876]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.876]                     {
[01:29:27.876]                       inherits <- base::inherits
[01:29:27.876]                       invokeRestart <- base::invokeRestart
[01:29:27.876]                       is.null <- base::is.null
[01:29:27.876]                       muffled <- FALSE
[01:29:27.876]                       if (inherits(cond, "message")) {
[01:29:27.876]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.876]                         if (muffled) 
[01:29:27.876]                           invokeRestart("muffleMessage")
[01:29:27.876]                       }
[01:29:27.876]                       else if (inherits(cond, "warning")) {
[01:29:27.876]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.876]                         if (muffled) 
[01:29:27.876]                           invokeRestart("muffleWarning")
[01:29:27.876]                       }
[01:29:27.876]                       else if (inherits(cond, "condition")) {
[01:29:27.876]                         if (!is.null(pattern)) {
[01:29:27.876]                           computeRestarts <- base::computeRestarts
[01:29:27.876]                           grepl <- base::grepl
[01:29:27.876]                           restarts <- computeRestarts(cond)
[01:29:27.876]                           for (restart in restarts) {
[01:29:27.876]                             name <- restart$name
[01:29:27.876]                             if (is.null(name)) 
[01:29:27.876]                               next
[01:29:27.876]                             if (!grepl(pattern, name)) 
[01:29:27.876]                               next
[01:29:27.876]                             invokeRestart(restart)
[01:29:27.876]                             muffled <- TRUE
[01:29:27.876]                             break
[01:29:27.876]                           }
[01:29:27.876]                         }
[01:29:27.876]                       }
[01:29:27.876]                       invisible(muffled)
[01:29:27.876]                     }
[01:29:27.876]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.876]                   }
[01:29:27.876]                 }
[01:29:27.876]                 else {
[01:29:27.876]                   if (TRUE) {
[01:29:27.876]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.876]                     {
[01:29:27.876]                       inherits <- base::inherits
[01:29:27.876]                       invokeRestart <- base::invokeRestart
[01:29:27.876]                       is.null <- base::is.null
[01:29:27.876]                       muffled <- FALSE
[01:29:27.876]                       if (inherits(cond, "message")) {
[01:29:27.876]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.876]                         if (muffled) 
[01:29:27.876]                           invokeRestart("muffleMessage")
[01:29:27.876]                       }
[01:29:27.876]                       else if (inherits(cond, "warning")) {
[01:29:27.876]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.876]                         if (muffled) 
[01:29:27.876]                           invokeRestart("muffleWarning")
[01:29:27.876]                       }
[01:29:27.876]                       else if (inherits(cond, "condition")) {
[01:29:27.876]                         if (!is.null(pattern)) {
[01:29:27.876]                           computeRestarts <- base::computeRestarts
[01:29:27.876]                           grepl <- base::grepl
[01:29:27.876]                           restarts <- computeRestarts(cond)
[01:29:27.876]                           for (restart in restarts) {
[01:29:27.876]                             name <- restart$name
[01:29:27.876]                             if (is.null(name)) 
[01:29:27.876]                               next
[01:29:27.876]                             if (!grepl(pattern, name)) 
[01:29:27.876]                               next
[01:29:27.876]                             invokeRestart(restart)
[01:29:27.876]                             muffled <- TRUE
[01:29:27.876]                             break
[01:29:27.876]                           }
[01:29:27.876]                         }
[01:29:27.876]                       }
[01:29:27.876]                       invisible(muffled)
[01:29:27.876]                     }
[01:29:27.876]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.876]                   }
[01:29:27.876]                 }
[01:29:27.876]             }
[01:29:27.876]         }))
[01:29:27.876]     }, error = function(ex) {
[01:29:27.876]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.876]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.876]                 ...future.rng), started = ...future.startTime, 
[01:29:27.876]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.876]             version = "1.8"), class = "FutureResult")
[01:29:27.876]     }, finally = {
[01:29:27.876]         if (!identical(...future.workdir, getwd())) 
[01:29:27.876]             setwd(...future.workdir)
[01:29:27.876]         {
[01:29:27.876]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.876]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.876]             }
[01:29:27.876]             base::options(...future.oldOptions)
[01:29:27.876]             if (.Platform$OS.type == "windows") {
[01:29:27.876]                 old_names <- names(...future.oldEnvVars)
[01:29:27.876]                 envs <- base::Sys.getenv()
[01:29:27.876]                 names <- names(envs)
[01:29:27.876]                 common <- intersect(names, old_names)
[01:29:27.876]                 added <- setdiff(names, old_names)
[01:29:27.876]                 removed <- setdiff(old_names, names)
[01:29:27.876]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.876]                   envs[common]]
[01:29:27.876]                 NAMES <- toupper(changed)
[01:29:27.876]                 args <- list()
[01:29:27.876]                 for (kk in seq_along(NAMES)) {
[01:29:27.876]                   name <- changed[[kk]]
[01:29:27.876]                   NAME <- NAMES[[kk]]
[01:29:27.876]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.876]                     next
[01:29:27.876]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.876]                 }
[01:29:27.876]                 NAMES <- toupper(added)
[01:29:27.876]                 for (kk in seq_along(NAMES)) {
[01:29:27.876]                   name <- added[[kk]]
[01:29:27.876]                   NAME <- NAMES[[kk]]
[01:29:27.876]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.876]                     next
[01:29:27.876]                   args[[name]] <- ""
[01:29:27.876]                 }
[01:29:27.876]                 NAMES <- toupper(removed)
[01:29:27.876]                 for (kk in seq_along(NAMES)) {
[01:29:27.876]                   name <- removed[[kk]]
[01:29:27.876]                   NAME <- NAMES[[kk]]
[01:29:27.876]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.876]                     next
[01:29:27.876]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.876]                 }
[01:29:27.876]                 if (length(args) > 0) 
[01:29:27.876]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.876]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.876]             }
[01:29:27.876]             else {
[01:29:27.876]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.876]             }
[01:29:27.876]             {
[01:29:27.876]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.876]                   0L) {
[01:29:27.876]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.876]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.876]                   base::options(opts)
[01:29:27.876]                 }
[01:29:27.876]                 {
[01:29:27.876]                   {
[01:29:27.876]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:27.876]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:27.876]                     -1344458670L), envir = base::globalenv(), 
[01:29:27.876]                       inherits = FALSE)
[01:29:27.876]                     NULL
[01:29:27.876]                   }
[01:29:27.876]                   options(future.plan = NULL)
[01:29:27.876]                   if (is.na(NA_character_)) 
[01:29:27.876]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.876]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.876]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.876]                   {
[01:29:27.876]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.876]                     if (!future$lazy) 
[01:29:27.876]                       future <- run(future)
[01:29:27.876]                     invisible(future)
[01:29:27.876]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.876]                 }
[01:29:27.876]             }
[01:29:27.876]         }
[01:29:27.876]     })
[01:29:27.876]     if (TRUE) {
[01:29:27.876]         base::sink(type = "output", split = FALSE)
[01:29:27.876]         if (TRUE) {
[01:29:27.876]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.876]         }
[01:29:27.876]         else {
[01:29:27.876]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.876]         }
[01:29:27.876]         base::close(...future.stdout)
[01:29:27.876]         ...future.stdout <- NULL
[01:29:27.876]     }
[01:29:27.876]     ...future.result$conditions <- ...future.conditions
[01:29:27.876]     ...future.result$finished <- base::Sys.time()
[01:29:27.876]     ...future.result
[01:29:27.876] }
[01:29:27.881] assign_globals() ...
[01:29:27.881] List of 1
[01:29:27.881]  $ x: int [1:4] 0 1 2 3
[01:29:27.881]  - attr(*, "where")=List of 1
[01:29:27.881]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.881]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.881]  - attr(*, "resolved")= logi FALSE
[01:29:27.881]  - attr(*, "total_size")= num 64
[01:29:27.881]  - attr(*, "already-done")= logi TRUE
[01:29:27.886] - copied 'x' to environment
[01:29:27.887] assign_globals() ... done
[01:29:27.887] plan(): Setting new future strategy stack:
[01:29:27.888] List of future strategies:
[01:29:27.888] 1. sequential:
[01:29:27.888]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.888]    - tweaked: FALSE
[01:29:27.888]    - call: NULL
[01:29:27.888] plan(): nbrOfWorkers() = 1
[01:29:27.890] plan(): Setting new future strategy stack:
[01:29:27.891] List of future strategies:
[01:29:27.891] 1. sequential:
[01:29:27.891]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.891]    - tweaked: FALSE
[01:29:27.891]    - call: plan(strategy)
[01:29:27.891] plan(): nbrOfWorkers() = 1
[01:29:27.892] SequentialFuture started (and completed)
[01:29:27.892] - Launch lazy future ... done
[01:29:27.892] run() for 'SequentialFuture' ... done
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[01:29:27.895] getGlobalsAndPackages() ...
[01:29:27.895] Searching for globals...
[01:29:27.897] - globals found: [3] '{', 'sample', 'x'
[01:29:27.897] Searching for globals ... DONE
[01:29:27.898] Resolving globals: FALSE
[01:29:27.899] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.899] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.899] - globals: [1] 'x'
[01:29:27.900] 
[01:29:27.900] getGlobalsAndPackages() ... DONE
[01:29:27.901] run() for 'Future' ...
[01:29:27.901] - state: 'created'
[01:29:27.901] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.902] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.902] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.902]   - Field: 'label'
[01:29:27.903]   - Field: 'local'
[01:29:27.906]   - Field: 'owner'
[01:29:27.907]   - Field: 'envir'
[01:29:27.907]   - Field: 'packages'
[01:29:27.907]   - Field: 'gc'
[01:29:27.908]   - Field: 'conditions'
[01:29:27.908]   - Field: 'expr'
[01:29:27.908]   - Field: 'uuid'
[01:29:27.909]   - Field: 'seed'
[01:29:27.909]   - Field: 'version'
[01:29:27.909]   - Field: 'result'
[01:29:27.910]   - Field: 'asynchronous'
[01:29:27.910]   - Field: 'calls'
[01:29:27.910]   - Field: 'globals'
[01:29:27.910]   - Field: 'stdout'
[01:29:27.911]   - Field: 'earlySignal'
[01:29:27.911]   - Field: 'lazy'
[01:29:27.911]   - Field: 'state'
[01:29:27.912] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.912] - Launch lazy future ...
[01:29:27.912] Packages needed by the future expression (n = 0): <none>
[01:29:27.912] Packages needed by future strategies (n = 0): <none>
[01:29:27.913] {
[01:29:27.913]     {
[01:29:27.913]         {
[01:29:27.913]             ...future.startTime <- base::Sys.time()
[01:29:27.913]             {
[01:29:27.913]                 {
[01:29:27.913]                   {
[01:29:27.913]                     {
[01:29:27.913]                       base::local({
[01:29:27.913]                         has_future <- base::requireNamespace("future", 
[01:29:27.913]                           quietly = TRUE)
[01:29:27.913]                         if (has_future) {
[01:29:27.913]                           ns <- base::getNamespace("future")
[01:29:27.913]                           version <- ns[[".package"]][["version"]]
[01:29:27.913]                           if (is.null(version)) 
[01:29:27.913]                             version <- utils::packageVersion("future")
[01:29:27.913]                         }
[01:29:27.913]                         else {
[01:29:27.913]                           version <- NULL
[01:29:27.913]                         }
[01:29:27.913]                         if (!has_future || version < "1.8.0") {
[01:29:27.913]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.913]                             "", base::R.version$version.string), 
[01:29:27.913]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:27.913]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.913]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.913]                               "release", "version")], collapse = " "), 
[01:29:27.913]                             hostname = base::Sys.info()[["nodename"]])
[01:29:27.913]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.913]                             info)
[01:29:27.913]                           info <- base::paste(info, collapse = "; ")
[01:29:27.913]                           if (!has_future) {
[01:29:27.913]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.913]                               info)
[01:29:27.913]                           }
[01:29:27.913]                           else {
[01:29:27.913]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.913]                               info, version)
[01:29:27.913]                           }
[01:29:27.913]                           base::stop(msg)
[01:29:27.913]                         }
[01:29:27.913]                       })
[01:29:27.913]                     }
[01:29:27.913]                     options(future.plan = NULL)
[01:29:27.913]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.913]                     future::plan("default", .cleanup = FALSE, 
[01:29:27.913]                       .init = FALSE)
[01:29:27.913]                   }
[01:29:27.913]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[01:29:27.913]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[01:29:27.913]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[01:29:27.913]                 }
[01:29:27.913]                 ...future.workdir <- getwd()
[01:29:27.913]             }
[01:29:27.913]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.913]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.913]         }
[01:29:27.913]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.913]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.913]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.913]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.913]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.913]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.913]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.913]             base::names(...future.oldOptions))
[01:29:27.913]     }
[01:29:27.913]     if (FALSE) {
[01:29:27.913]     }
[01:29:27.913]     else {
[01:29:27.913]         if (TRUE) {
[01:29:27.913]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.913]                 open = "w")
[01:29:27.913]         }
[01:29:27.913]         else {
[01:29:27.913]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.913]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.913]         }
[01:29:27.913]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.913]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.913]             base::sink(type = "output", split = FALSE)
[01:29:27.913]             base::close(...future.stdout)
[01:29:27.913]         }, add = TRUE)
[01:29:27.913]     }
[01:29:27.913]     ...future.frame <- base::sys.nframe()
[01:29:27.913]     ...future.conditions <- base::list()
[01:29:27.913]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.913]     if (FALSE) {
[01:29:27.913]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.913]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.913]     }
[01:29:27.913]     ...future.result <- base::tryCatch({
[01:29:27.913]         base::withCallingHandlers({
[01:29:27.913]             ...future.value <- base::withVisible(base::local({
[01:29:27.913]                 sample(x, size = 1L)
[01:29:27.913]             }))
[01:29:27.913]             future::FutureResult(value = ...future.value$value, 
[01:29:27.913]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.913]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.913]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.913]                     ...future.globalenv.names))
[01:29:27.913]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.913]         }, condition = base::local({
[01:29:27.913]             c <- base::c
[01:29:27.913]             inherits <- base::inherits
[01:29:27.913]             invokeRestart <- base::invokeRestart
[01:29:27.913]             length <- base::length
[01:29:27.913]             list <- base::list
[01:29:27.913]             seq.int <- base::seq.int
[01:29:27.913]             signalCondition <- base::signalCondition
[01:29:27.913]             sys.calls <- base::sys.calls
[01:29:27.913]             `[[` <- base::`[[`
[01:29:27.913]             `+` <- base::`+`
[01:29:27.913]             `<<-` <- base::`<<-`
[01:29:27.913]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.913]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.913]                   3L)]
[01:29:27.913]             }
[01:29:27.913]             function(cond) {
[01:29:27.913]                 is_error <- inherits(cond, "error")
[01:29:27.913]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.913]                   NULL)
[01:29:27.913]                 if (is_error) {
[01:29:27.913]                   sessionInformation <- function() {
[01:29:27.913]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.913]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.913]                       search = base::search(), system = base::Sys.info())
[01:29:27.913]                   }
[01:29:27.913]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.913]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.913]                     cond$call), session = sessionInformation(), 
[01:29:27.913]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.913]                   signalCondition(cond)
[01:29:27.913]                 }
[01:29:27.913]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.913]                 "immediateCondition"))) {
[01:29:27.913]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.913]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.913]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.913]                   if (TRUE && !signal) {
[01:29:27.913]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.913]                     {
[01:29:27.913]                       inherits <- base::inherits
[01:29:27.913]                       invokeRestart <- base::invokeRestart
[01:29:27.913]                       is.null <- base::is.null
[01:29:27.913]                       muffled <- FALSE
[01:29:27.913]                       if (inherits(cond, "message")) {
[01:29:27.913]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.913]                         if (muffled) 
[01:29:27.913]                           invokeRestart("muffleMessage")
[01:29:27.913]                       }
[01:29:27.913]                       else if (inherits(cond, "warning")) {
[01:29:27.913]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.913]                         if (muffled) 
[01:29:27.913]                           invokeRestart("muffleWarning")
[01:29:27.913]                       }
[01:29:27.913]                       else if (inherits(cond, "condition")) {
[01:29:27.913]                         if (!is.null(pattern)) {
[01:29:27.913]                           computeRestarts <- base::computeRestarts
[01:29:27.913]                           grepl <- base::grepl
[01:29:27.913]                           restarts <- computeRestarts(cond)
[01:29:27.913]                           for (restart in restarts) {
[01:29:27.913]                             name <- restart$name
[01:29:27.913]                             if (is.null(name)) 
[01:29:27.913]                               next
[01:29:27.913]                             if (!grepl(pattern, name)) 
[01:29:27.913]                               next
[01:29:27.913]                             invokeRestart(restart)
[01:29:27.913]                             muffled <- TRUE
[01:29:27.913]                             break
[01:29:27.913]                           }
[01:29:27.913]                         }
[01:29:27.913]                       }
[01:29:27.913]                       invisible(muffled)
[01:29:27.913]                     }
[01:29:27.913]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.913]                   }
[01:29:27.913]                 }
[01:29:27.913]                 else {
[01:29:27.913]                   if (TRUE) {
[01:29:27.913]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.913]                     {
[01:29:27.913]                       inherits <- base::inherits
[01:29:27.913]                       invokeRestart <- base::invokeRestart
[01:29:27.913]                       is.null <- base::is.null
[01:29:27.913]                       muffled <- FALSE
[01:29:27.913]                       if (inherits(cond, "message")) {
[01:29:27.913]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.913]                         if (muffled) 
[01:29:27.913]                           invokeRestart("muffleMessage")
[01:29:27.913]                       }
[01:29:27.913]                       else if (inherits(cond, "warning")) {
[01:29:27.913]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.913]                         if (muffled) 
[01:29:27.913]                           invokeRestart("muffleWarning")
[01:29:27.913]                       }
[01:29:27.913]                       else if (inherits(cond, "condition")) {
[01:29:27.913]                         if (!is.null(pattern)) {
[01:29:27.913]                           computeRestarts <- base::computeRestarts
[01:29:27.913]                           grepl <- base::grepl
[01:29:27.913]                           restarts <- computeRestarts(cond)
[01:29:27.913]                           for (restart in restarts) {
[01:29:27.913]                             name <- restart$name
[01:29:27.913]                             if (is.null(name)) 
[01:29:27.913]                               next
[01:29:27.913]                             if (!grepl(pattern, name)) 
[01:29:27.913]                               next
[01:29:27.913]                             invokeRestart(restart)
[01:29:27.913]                             muffled <- TRUE
[01:29:27.913]                             break
[01:29:27.913]                           }
[01:29:27.913]                         }
[01:29:27.913]                       }
[01:29:27.913]                       invisible(muffled)
[01:29:27.913]                     }
[01:29:27.913]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.913]                   }
[01:29:27.913]                 }
[01:29:27.913]             }
[01:29:27.913]         }))
[01:29:27.913]     }, error = function(ex) {
[01:29:27.913]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.913]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.913]                 ...future.rng), started = ...future.startTime, 
[01:29:27.913]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.913]             version = "1.8"), class = "FutureResult")
[01:29:27.913]     }, finally = {
[01:29:27.913]         if (!identical(...future.workdir, getwd())) 
[01:29:27.913]             setwd(...future.workdir)
[01:29:27.913]         {
[01:29:27.913]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.913]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.913]             }
[01:29:27.913]             base::options(...future.oldOptions)
[01:29:27.913]             if (.Platform$OS.type == "windows") {
[01:29:27.913]                 old_names <- names(...future.oldEnvVars)
[01:29:27.913]                 envs <- base::Sys.getenv()
[01:29:27.913]                 names <- names(envs)
[01:29:27.913]                 common <- intersect(names, old_names)
[01:29:27.913]                 added <- setdiff(names, old_names)
[01:29:27.913]                 removed <- setdiff(old_names, names)
[01:29:27.913]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.913]                   envs[common]]
[01:29:27.913]                 NAMES <- toupper(changed)
[01:29:27.913]                 args <- list()
[01:29:27.913]                 for (kk in seq_along(NAMES)) {
[01:29:27.913]                   name <- changed[[kk]]
[01:29:27.913]                   NAME <- NAMES[[kk]]
[01:29:27.913]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.913]                     next
[01:29:27.913]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.913]                 }
[01:29:27.913]                 NAMES <- toupper(added)
[01:29:27.913]                 for (kk in seq_along(NAMES)) {
[01:29:27.913]                   name <- added[[kk]]
[01:29:27.913]                   NAME <- NAMES[[kk]]
[01:29:27.913]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.913]                     next
[01:29:27.913]                   args[[name]] <- ""
[01:29:27.913]                 }
[01:29:27.913]                 NAMES <- toupper(removed)
[01:29:27.913]                 for (kk in seq_along(NAMES)) {
[01:29:27.913]                   name <- removed[[kk]]
[01:29:27.913]                   NAME <- NAMES[[kk]]
[01:29:27.913]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.913]                     next
[01:29:27.913]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.913]                 }
[01:29:27.913]                 if (length(args) > 0) 
[01:29:27.913]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.913]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.913]             }
[01:29:27.913]             else {
[01:29:27.913]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.913]             }
[01:29:27.913]             {
[01:29:27.913]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.913]                   0L) {
[01:29:27.913]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.913]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.913]                   base::options(opts)
[01:29:27.913]                 }
[01:29:27.913]                 {
[01:29:27.913]                   {
[01:29:27.913]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:27.913]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:27.913]                     -1344458670L), envir = base::globalenv(), 
[01:29:27.913]                       inherits = FALSE)
[01:29:27.913]                     NULL
[01:29:27.913]                   }
[01:29:27.913]                   options(future.plan = NULL)
[01:29:27.913]                   if (is.na(NA_character_)) 
[01:29:27.913]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.913]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.913]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.913]                   {
[01:29:27.913]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.913]                     if (!future$lazy) 
[01:29:27.913]                       future <- run(future)
[01:29:27.913]                     invisible(future)
[01:29:27.913]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.913]                 }
[01:29:27.913]             }
[01:29:27.913]         }
[01:29:27.913]     })
[01:29:27.913]     if (TRUE) {
[01:29:27.913]         base::sink(type = "output", split = FALSE)
[01:29:27.913]         if (TRUE) {
[01:29:27.913]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.913]         }
[01:29:27.913]         else {
[01:29:27.913]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.913]         }
[01:29:27.913]         base::close(...future.stdout)
[01:29:27.913]         ...future.stdout <- NULL
[01:29:27.913]     }
[01:29:27.913]     ...future.result$conditions <- ...future.conditions
[01:29:27.913]     ...future.result$finished <- base::Sys.time()
[01:29:27.913]     ...future.result
[01:29:27.913] }
[01:29:27.917] assign_globals() ...
[01:29:27.918] List of 1
[01:29:27.918]  $ x: int [1:4] 0 1 2 3
[01:29:27.918]  - attr(*, "where")=List of 1
[01:29:27.918]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.918]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.918]  - attr(*, "resolved")= logi FALSE
[01:29:27.918]  - attr(*, "total_size")= num 64
[01:29:27.918]  - attr(*, "already-done")= logi TRUE
[01:29:27.921] - copied 'x' to environment
[01:29:27.922] assign_globals() ... done
[01:29:27.922] plan(): Setting new future strategy stack:
[01:29:27.922] List of future strategies:
[01:29:27.922] 1. sequential:
[01:29:27.922]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.922]    - tweaked: FALSE
[01:29:27.922]    - call: NULL
[01:29:27.923] plan(): nbrOfWorkers() = 1
[01:29:27.924] plan(): Setting new future strategy stack:
[01:29:27.925] List of future strategies:
[01:29:27.925] 1. sequential:
[01:29:27.925]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.925]    - tweaked: FALSE
[01:29:27.925]    - call: plan(strategy)
[01:29:27.925] plan(): nbrOfWorkers() = 1
[01:29:27.926] SequentialFuture started (and completed)
[01:29:27.926] - Launch lazy future ... done
[01:29:27.926] run() for 'SequentialFuture' ... done
[01:29:27.927] getGlobalsAndPackages() ...
[01:29:27.927] Searching for globals...
[01:29:27.929] - globals found: [3] '{', 'sample', 'x'
[01:29:27.929] Searching for globals ... DONE
[01:29:27.929] Resolving globals: FALSE
[01:29:27.930] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.930] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.930] - globals: [1] 'x'
[01:29:27.931] 
[01:29:27.931] getGlobalsAndPackages() ... DONE
[01:29:27.931] run() for 'Future' ...
[01:29:27.931] - state: 'created'
[01:29:27.932] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.932] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.932] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.932]   - Field: 'label'
[01:29:27.933]   - Field: 'local'
[01:29:27.933]   - Field: 'owner'
[01:29:27.933]   - Field: 'envir'
[01:29:27.933]   - Field: 'packages'
[01:29:27.933]   - Field: 'gc'
[01:29:27.934]   - Field: 'conditions'
[01:29:27.934]   - Field: 'expr'
[01:29:27.934]   - Field: 'uuid'
[01:29:27.934]   - Field: 'seed'
[01:29:27.935]   - Field: 'version'
[01:29:27.935]   - Field: 'result'
[01:29:27.935]   - Field: 'asynchronous'
[01:29:27.935]   - Field: 'calls'
[01:29:27.935]   - Field: 'globals'
[01:29:27.936]   - Field: 'stdout'
[01:29:27.936]   - Field: 'earlySignal'
[01:29:27.936]   - Field: 'lazy'
[01:29:27.936]   - Field: 'state'
[01:29:27.936] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.937] - Launch lazy future ...
[01:29:27.937] Packages needed by the future expression (n = 0): <none>
[01:29:27.937] Packages needed by future strategies (n = 0): <none>
[01:29:27.938] {
[01:29:27.938]     {
[01:29:27.938]         {
[01:29:27.938]             ...future.startTime <- base::Sys.time()
[01:29:27.938]             {
[01:29:27.938]                 {
[01:29:27.938]                   {
[01:29:27.938]                     {
[01:29:27.938]                       base::local({
[01:29:27.938]                         has_future <- base::requireNamespace("future", 
[01:29:27.938]                           quietly = TRUE)
[01:29:27.938]                         if (has_future) {
[01:29:27.938]                           ns <- base::getNamespace("future")
[01:29:27.938]                           version <- ns[[".package"]][["version"]]
[01:29:27.938]                           if (is.null(version)) 
[01:29:27.938]                             version <- utils::packageVersion("future")
[01:29:27.938]                         }
[01:29:27.938]                         else {
[01:29:27.938]                           version <- NULL
[01:29:27.938]                         }
[01:29:27.938]                         if (!has_future || version < "1.8.0") {
[01:29:27.938]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.938]                             "", base::R.version$version.string), 
[01:29:27.938]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:27.938]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.938]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.938]                               "release", "version")], collapse = " "), 
[01:29:27.938]                             hostname = base::Sys.info()[["nodename"]])
[01:29:27.938]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.938]                             info)
[01:29:27.938]                           info <- base::paste(info, collapse = "; ")
[01:29:27.938]                           if (!has_future) {
[01:29:27.938]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.938]                               info)
[01:29:27.938]                           }
[01:29:27.938]                           else {
[01:29:27.938]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.938]                               info, version)
[01:29:27.938]                           }
[01:29:27.938]                           base::stop(msg)
[01:29:27.938]                         }
[01:29:27.938]                       })
[01:29:27.938]                     }
[01:29:27.938]                     options(future.plan = NULL)
[01:29:27.938]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.938]                     future::plan("default", .cleanup = FALSE, 
[01:29:27.938]                       .init = FALSE)
[01:29:27.938]                   }
[01:29:27.938]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[01:29:27.938]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[01:29:27.938]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[01:29:27.938]                 }
[01:29:27.938]                 ...future.workdir <- getwd()
[01:29:27.938]             }
[01:29:27.938]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.938]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.938]         }
[01:29:27.938]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.938]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.938]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.938]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.938]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.938]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.938]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.938]             base::names(...future.oldOptions))
[01:29:27.938]     }
[01:29:27.938]     if (FALSE) {
[01:29:27.938]     }
[01:29:27.938]     else {
[01:29:27.938]         if (TRUE) {
[01:29:27.938]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.938]                 open = "w")
[01:29:27.938]         }
[01:29:27.938]         else {
[01:29:27.938]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.938]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.938]         }
[01:29:27.938]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.938]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.938]             base::sink(type = "output", split = FALSE)
[01:29:27.938]             base::close(...future.stdout)
[01:29:27.938]         }, add = TRUE)
[01:29:27.938]     }
[01:29:27.938]     ...future.frame <- base::sys.nframe()
[01:29:27.938]     ...future.conditions <- base::list()
[01:29:27.938]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.938]     if (FALSE) {
[01:29:27.938]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.938]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.938]     }
[01:29:27.938]     ...future.result <- base::tryCatch({
[01:29:27.938]         base::withCallingHandlers({
[01:29:27.938]             ...future.value <- base::withVisible(base::local({
[01:29:27.938]                 sample(x, size = 1L)
[01:29:27.938]             }))
[01:29:27.938]             future::FutureResult(value = ...future.value$value, 
[01:29:27.938]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.938]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.938]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.938]                     ...future.globalenv.names))
[01:29:27.938]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.938]         }, condition = base::local({
[01:29:27.938]             c <- base::c
[01:29:27.938]             inherits <- base::inherits
[01:29:27.938]             invokeRestart <- base::invokeRestart
[01:29:27.938]             length <- base::length
[01:29:27.938]             list <- base::list
[01:29:27.938]             seq.int <- base::seq.int
[01:29:27.938]             signalCondition <- base::signalCondition
[01:29:27.938]             sys.calls <- base::sys.calls
[01:29:27.938]             `[[` <- base::`[[`
[01:29:27.938]             `+` <- base::`+`
[01:29:27.938]             `<<-` <- base::`<<-`
[01:29:27.938]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.938]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.938]                   3L)]
[01:29:27.938]             }
[01:29:27.938]             function(cond) {
[01:29:27.938]                 is_error <- inherits(cond, "error")
[01:29:27.938]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.938]                   NULL)
[01:29:27.938]                 if (is_error) {
[01:29:27.938]                   sessionInformation <- function() {
[01:29:27.938]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.938]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.938]                       search = base::search(), system = base::Sys.info())
[01:29:27.938]                   }
[01:29:27.938]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.938]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.938]                     cond$call), session = sessionInformation(), 
[01:29:27.938]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.938]                   signalCondition(cond)
[01:29:27.938]                 }
[01:29:27.938]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.938]                 "immediateCondition"))) {
[01:29:27.938]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.938]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.938]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.938]                   if (TRUE && !signal) {
[01:29:27.938]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.938]                     {
[01:29:27.938]                       inherits <- base::inherits
[01:29:27.938]                       invokeRestart <- base::invokeRestart
[01:29:27.938]                       is.null <- base::is.null
[01:29:27.938]                       muffled <- FALSE
[01:29:27.938]                       if (inherits(cond, "message")) {
[01:29:27.938]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.938]                         if (muffled) 
[01:29:27.938]                           invokeRestart("muffleMessage")
[01:29:27.938]                       }
[01:29:27.938]                       else if (inherits(cond, "warning")) {
[01:29:27.938]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.938]                         if (muffled) 
[01:29:27.938]                           invokeRestart("muffleWarning")
[01:29:27.938]                       }
[01:29:27.938]                       else if (inherits(cond, "condition")) {
[01:29:27.938]                         if (!is.null(pattern)) {
[01:29:27.938]                           computeRestarts <- base::computeRestarts
[01:29:27.938]                           grepl <- base::grepl
[01:29:27.938]                           restarts <- computeRestarts(cond)
[01:29:27.938]                           for (restart in restarts) {
[01:29:27.938]                             name <- restart$name
[01:29:27.938]                             if (is.null(name)) 
[01:29:27.938]                               next
[01:29:27.938]                             if (!grepl(pattern, name)) 
[01:29:27.938]                               next
[01:29:27.938]                             invokeRestart(restart)
[01:29:27.938]                             muffled <- TRUE
[01:29:27.938]                             break
[01:29:27.938]                           }
[01:29:27.938]                         }
[01:29:27.938]                       }
[01:29:27.938]                       invisible(muffled)
[01:29:27.938]                     }
[01:29:27.938]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.938]                   }
[01:29:27.938]                 }
[01:29:27.938]                 else {
[01:29:27.938]                   if (TRUE) {
[01:29:27.938]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.938]                     {
[01:29:27.938]                       inherits <- base::inherits
[01:29:27.938]                       invokeRestart <- base::invokeRestart
[01:29:27.938]                       is.null <- base::is.null
[01:29:27.938]                       muffled <- FALSE
[01:29:27.938]                       if (inherits(cond, "message")) {
[01:29:27.938]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.938]                         if (muffled) 
[01:29:27.938]                           invokeRestart("muffleMessage")
[01:29:27.938]                       }
[01:29:27.938]                       else if (inherits(cond, "warning")) {
[01:29:27.938]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.938]                         if (muffled) 
[01:29:27.938]                           invokeRestart("muffleWarning")
[01:29:27.938]                       }
[01:29:27.938]                       else if (inherits(cond, "condition")) {
[01:29:27.938]                         if (!is.null(pattern)) {
[01:29:27.938]                           computeRestarts <- base::computeRestarts
[01:29:27.938]                           grepl <- base::grepl
[01:29:27.938]                           restarts <- computeRestarts(cond)
[01:29:27.938]                           for (restart in restarts) {
[01:29:27.938]                             name <- restart$name
[01:29:27.938]                             if (is.null(name)) 
[01:29:27.938]                               next
[01:29:27.938]                             if (!grepl(pattern, name)) 
[01:29:27.938]                               next
[01:29:27.938]                             invokeRestart(restart)
[01:29:27.938]                             muffled <- TRUE
[01:29:27.938]                             break
[01:29:27.938]                           }
[01:29:27.938]                         }
[01:29:27.938]                       }
[01:29:27.938]                       invisible(muffled)
[01:29:27.938]                     }
[01:29:27.938]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.938]                   }
[01:29:27.938]                 }
[01:29:27.938]             }
[01:29:27.938]         }))
[01:29:27.938]     }, error = function(ex) {
[01:29:27.938]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.938]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.938]                 ...future.rng), started = ...future.startTime, 
[01:29:27.938]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.938]             version = "1.8"), class = "FutureResult")
[01:29:27.938]     }, finally = {
[01:29:27.938]         if (!identical(...future.workdir, getwd())) 
[01:29:27.938]             setwd(...future.workdir)
[01:29:27.938]         {
[01:29:27.938]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.938]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.938]             }
[01:29:27.938]             base::options(...future.oldOptions)
[01:29:27.938]             if (.Platform$OS.type == "windows") {
[01:29:27.938]                 old_names <- names(...future.oldEnvVars)
[01:29:27.938]                 envs <- base::Sys.getenv()
[01:29:27.938]                 names <- names(envs)
[01:29:27.938]                 common <- intersect(names, old_names)
[01:29:27.938]                 added <- setdiff(names, old_names)
[01:29:27.938]                 removed <- setdiff(old_names, names)
[01:29:27.938]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.938]                   envs[common]]
[01:29:27.938]                 NAMES <- toupper(changed)
[01:29:27.938]                 args <- list()
[01:29:27.938]                 for (kk in seq_along(NAMES)) {
[01:29:27.938]                   name <- changed[[kk]]
[01:29:27.938]                   NAME <- NAMES[[kk]]
[01:29:27.938]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.938]                     next
[01:29:27.938]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.938]                 }
[01:29:27.938]                 NAMES <- toupper(added)
[01:29:27.938]                 for (kk in seq_along(NAMES)) {
[01:29:27.938]                   name <- added[[kk]]
[01:29:27.938]                   NAME <- NAMES[[kk]]
[01:29:27.938]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.938]                     next
[01:29:27.938]                   args[[name]] <- ""
[01:29:27.938]                 }
[01:29:27.938]                 NAMES <- toupper(removed)
[01:29:27.938]                 for (kk in seq_along(NAMES)) {
[01:29:27.938]                   name <- removed[[kk]]
[01:29:27.938]                   NAME <- NAMES[[kk]]
[01:29:27.938]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.938]                     next
[01:29:27.938]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.938]                 }
[01:29:27.938]                 if (length(args) > 0) 
[01:29:27.938]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.938]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.938]             }
[01:29:27.938]             else {
[01:29:27.938]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.938]             }
[01:29:27.938]             {
[01:29:27.938]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.938]                   0L) {
[01:29:27.938]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.938]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.938]                   base::options(opts)
[01:29:27.938]                 }
[01:29:27.938]                 {
[01:29:27.938]                   {
[01:29:27.938]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:27.938]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:27.938]                     -1344458670L), envir = base::globalenv(), 
[01:29:27.938]                       inherits = FALSE)
[01:29:27.938]                     NULL
[01:29:27.938]                   }
[01:29:27.938]                   options(future.plan = NULL)
[01:29:27.938]                   if (is.na(NA_character_)) 
[01:29:27.938]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.938]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.938]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.938]                   {
[01:29:27.938]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.938]                     if (!future$lazy) 
[01:29:27.938]                       future <- run(future)
[01:29:27.938]                     invisible(future)
[01:29:27.938]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.938]                 }
[01:29:27.938]             }
[01:29:27.938]         }
[01:29:27.938]     })
[01:29:27.938]     if (TRUE) {
[01:29:27.938]         base::sink(type = "output", split = FALSE)
[01:29:27.938]         if (TRUE) {
[01:29:27.938]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.938]         }
[01:29:27.938]         else {
[01:29:27.938]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.938]         }
[01:29:27.938]         base::close(...future.stdout)
[01:29:27.938]         ...future.stdout <- NULL
[01:29:27.938]     }
[01:29:27.938]     ...future.result$conditions <- ...future.conditions
[01:29:27.938]     ...future.result$finished <- base::Sys.time()
[01:29:27.938]     ...future.result
[01:29:27.938] }
[01:29:27.942] assign_globals() ...
[01:29:27.942] List of 1
[01:29:27.942]  $ x: int [1:4] 0 1 2 3
[01:29:27.942]  - attr(*, "where")=List of 1
[01:29:27.942]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.942]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.942]  - attr(*, "resolved")= logi FALSE
[01:29:27.942]  - attr(*, "total_size")= num 64
[01:29:27.942]  - attr(*, "already-done")= logi TRUE
[01:29:27.945] - copied 'x' to environment
[01:29:27.946] assign_globals() ... done
[01:29:27.946] plan(): Setting new future strategy stack:
[01:29:27.946] List of future strategies:
[01:29:27.946] 1. sequential:
[01:29:27.946]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.946]    - tweaked: FALSE
[01:29:27.946]    - call: NULL
[01:29:27.948] plan(): nbrOfWorkers() = 1
[01:29:27.950] plan(): Setting new future strategy stack:
[01:29:27.950] List of future strategies:
[01:29:27.950] 1. sequential:
[01:29:27.950]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.950]    - tweaked: FALSE
[01:29:27.950]    - call: plan(strategy)
[01:29:27.951] plan(): nbrOfWorkers() = 1
[01:29:27.951] SequentialFuture started (and completed)
[01:29:27.951] - Launch lazy future ... done
[01:29:27.951] run() for 'SequentialFuture' ... done
[01:29:27.952] getGlobalsAndPackages() ...
[01:29:27.952] Searching for globals...
[01:29:27.953] - globals found: [3] '{', 'sample', 'x'
[01:29:27.953] Searching for globals ... DONE
[01:29:27.954] Resolving globals: FALSE
[01:29:27.954] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.955] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.955] - globals: [1] 'x'
[01:29:27.955] 
[01:29:27.955] getGlobalsAndPackages() ... DONE
[01:29:27.956] run() for 'Future' ...
[01:29:27.956] - state: 'created'
[01:29:27.956] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.956] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.957] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.957]   - Field: 'label'
[01:29:27.957]   - Field: 'local'
[01:29:27.957]   - Field: 'owner'
[01:29:27.957]   - Field: 'envir'
[01:29:27.957]   - Field: 'packages'
[01:29:27.958]   - Field: 'gc'
[01:29:27.958]   - Field: 'conditions'
[01:29:27.958]   - Field: 'expr'
[01:29:27.958]   - Field: 'uuid'
[01:29:27.958]   - Field: 'seed'
[01:29:27.959]   - Field: 'version'
[01:29:27.959]   - Field: 'result'
[01:29:27.959]   - Field: 'asynchronous'
[01:29:27.959]   - Field: 'calls'
[01:29:27.959]   - Field: 'globals'
[01:29:27.960]   - Field: 'stdout'
[01:29:27.960]   - Field: 'earlySignal'
[01:29:27.960]   - Field: 'lazy'
[01:29:27.960]   - Field: 'state'
[01:29:27.960] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.960] - Launch lazy future ...
[01:29:27.961] Packages needed by the future expression (n = 0): <none>
[01:29:27.961] Packages needed by future strategies (n = 0): <none>
[01:29:27.961] {
[01:29:27.961]     {
[01:29:27.961]         {
[01:29:27.961]             ...future.startTime <- base::Sys.time()
[01:29:27.961]             {
[01:29:27.961]                 {
[01:29:27.961]                   {
[01:29:27.961]                     {
[01:29:27.961]                       base::local({
[01:29:27.961]                         has_future <- base::requireNamespace("future", 
[01:29:27.961]                           quietly = TRUE)
[01:29:27.961]                         if (has_future) {
[01:29:27.961]                           ns <- base::getNamespace("future")
[01:29:27.961]                           version <- ns[[".package"]][["version"]]
[01:29:27.961]                           if (is.null(version)) 
[01:29:27.961]                             version <- utils::packageVersion("future")
[01:29:27.961]                         }
[01:29:27.961]                         else {
[01:29:27.961]                           version <- NULL
[01:29:27.961]                         }
[01:29:27.961]                         if (!has_future || version < "1.8.0") {
[01:29:27.961]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.961]                             "", base::R.version$version.string), 
[01:29:27.961]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:27.961]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.961]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.961]                               "release", "version")], collapse = " "), 
[01:29:27.961]                             hostname = base::Sys.info()[["nodename"]])
[01:29:27.961]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.961]                             info)
[01:29:27.961]                           info <- base::paste(info, collapse = "; ")
[01:29:27.961]                           if (!has_future) {
[01:29:27.961]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.961]                               info)
[01:29:27.961]                           }
[01:29:27.961]                           else {
[01:29:27.961]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.961]                               info, version)
[01:29:27.961]                           }
[01:29:27.961]                           base::stop(msg)
[01:29:27.961]                         }
[01:29:27.961]                       })
[01:29:27.961]                     }
[01:29:27.961]                     options(future.plan = NULL)
[01:29:27.961]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.961]                     future::plan("default", .cleanup = FALSE, 
[01:29:27.961]                       .init = FALSE)
[01:29:27.961]                   }
[01:29:27.961]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[01:29:27.961]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[01:29:27.961]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[01:29:27.961]                 }
[01:29:27.961]                 ...future.workdir <- getwd()
[01:29:27.961]             }
[01:29:27.961]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.961]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.961]         }
[01:29:27.961]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.961]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.961]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.961]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.961]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.961]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.961]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.961]             base::names(...future.oldOptions))
[01:29:27.961]     }
[01:29:27.961]     if (FALSE) {
[01:29:27.961]     }
[01:29:27.961]     else {
[01:29:27.961]         if (TRUE) {
[01:29:27.961]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.961]                 open = "w")
[01:29:27.961]         }
[01:29:27.961]         else {
[01:29:27.961]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.961]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.961]         }
[01:29:27.961]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.961]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.961]             base::sink(type = "output", split = FALSE)
[01:29:27.961]             base::close(...future.stdout)
[01:29:27.961]         }, add = TRUE)
[01:29:27.961]     }
[01:29:27.961]     ...future.frame <- base::sys.nframe()
[01:29:27.961]     ...future.conditions <- base::list()
[01:29:27.961]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.961]     if (FALSE) {
[01:29:27.961]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.961]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.961]     }
[01:29:27.961]     ...future.result <- base::tryCatch({
[01:29:27.961]         base::withCallingHandlers({
[01:29:27.961]             ...future.value <- base::withVisible(base::local({
[01:29:27.961]                 sample(x, size = 1L)
[01:29:27.961]             }))
[01:29:27.961]             future::FutureResult(value = ...future.value$value, 
[01:29:27.961]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.961]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.961]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.961]                     ...future.globalenv.names))
[01:29:27.961]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.961]         }, condition = base::local({
[01:29:27.961]             c <- base::c
[01:29:27.961]             inherits <- base::inherits
[01:29:27.961]             invokeRestart <- base::invokeRestart
[01:29:27.961]             length <- base::length
[01:29:27.961]             list <- base::list
[01:29:27.961]             seq.int <- base::seq.int
[01:29:27.961]             signalCondition <- base::signalCondition
[01:29:27.961]             sys.calls <- base::sys.calls
[01:29:27.961]             `[[` <- base::`[[`
[01:29:27.961]             `+` <- base::`+`
[01:29:27.961]             `<<-` <- base::`<<-`
[01:29:27.961]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.961]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.961]                   3L)]
[01:29:27.961]             }
[01:29:27.961]             function(cond) {
[01:29:27.961]                 is_error <- inherits(cond, "error")
[01:29:27.961]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.961]                   NULL)
[01:29:27.961]                 if (is_error) {
[01:29:27.961]                   sessionInformation <- function() {
[01:29:27.961]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.961]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.961]                       search = base::search(), system = base::Sys.info())
[01:29:27.961]                   }
[01:29:27.961]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.961]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.961]                     cond$call), session = sessionInformation(), 
[01:29:27.961]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.961]                   signalCondition(cond)
[01:29:27.961]                 }
[01:29:27.961]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.961]                 "immediateCondition"))) {
[01:29:27.961]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.961]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.961]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.961]                   if (TRUE && !signal) {
[01:29:27.961]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.961]                     {
[01:29:27.961]                       inherits <- base::inherits
[01:29:27.961]                       invokeRestart <- base::invokeRestart
[01:29:27.961]                       is.null <- base::is.null
[01:29:27.961]                       muffled <- FALSE
[01:29:27.961]                       if (inherits(cond, "message")) {
[01:29:27.961]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.961]                         if (muffled) 
[01:29:27.961]                           invokeRestart("muffleMessage")
[01:29:27.961]                       }
[01:29:27.961]                       else if (inherits(cond, "warning")) {
[01:29:27.961]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.961]                         if (muffled) 
[01:29:27.961]                           invokeRestart("muffleWarning")
[01:29:27.961]                       }
[01:29:27.961]                       else if (inherits(cond, "condition")) {
[01:29:27.961]                         if (!is.null(pattern)) {
[01:29:27.961]                           computeRestarts <- base::computeRestarts
[01:29:27.961]                           grepl <- base::grepl
[01:29:27.961]                           restarts <- computeRestarts(cond)
[01:29:27.961]                           for (restart in restarts) {
[01:29:27.961]                             name <- restart$name
[01:29:27.961]                             if (is.null(name)) 
[01:29:27.961]                               next
[01:29:27.961]                             if (!grepl(pattern, name)) 
[01:29:27.961]                               next
[01:29:27.961]                             invokeRestart(restart)
[01:29:27.961]                             muffled <- TRUE
[01:29:27.961]                             break
[01:29:27.961]                           }
[01:29:27.961]                         }
[01:29:27.961]                       }
[01:29:27.961]                       invisible(muffled)
[01:29:27.961]                     }
[01:29:27.961]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.961]                   }
[01:29:27.961]                 }
[01:29:27.961]                 else {
[01:29:27.961]                   if (TRUE) {
[01:29:27.961]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.961]                     {
[01:29:27.961]                       inherits <- base::inherits
[01:29:27.961]                       invokeRestart <- base::invokeRestart
[01:29:27.961]                       is.null <- base::is.null
[01:29:27.961]                       muffled <- FALSE
[01:29:27.961]                       if (inherits(cond, "message")) {
[01:29:27.961]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.961]                         if (muffled) 
[01:29:27.961]                           invokeRestart("muffleMessage")
[01:29:27.961]                       }
[01:29:27.961]                       else if (inherits(cond, "warning")) {
[01:29:27.961]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.961]                         if (muffled) 
[01:29:27.961]                           invokeRestart("muffleWarning")
[01:29:27.961]                       }
[01:29:27.961]                       else if (inherits(cond, "condition")) {
[01:29:27.961]                         if (!is.null(pattern)) {
[01:29:27.961]                           computeRestarts <- base::computeRestarts
[01:29:27.961]                           grepl <- base::grepl
[01:29:27.961]                           restarts <- computeRestarts(cond)
[01:29:27.961]                           for (restart in restarts) {
[01:29:27.961]                             name <- restart$name
[01:29:27.961]                             if (is.null(name)) 
[01:29:27.961]                               next
[01:29:27.961]                             if (!grepl(pattern, name)) 
[01:29:27.961]                               next
[01:29:27.961]                             invokeRestart(restart)
[01:29:27.961]                             muffled <- TRUE
[01:29:27.961]                             break
[01:29:27.961]                           }
[01:29:27.961]                         }
[01:29:27.961]                       }
[01:29:27.961]                       invisible(muffled)
[01:29:27.961]                     }
[01:29:27.961]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.961]                   }
[01:29:27.961]                 }
[01:29:27.961]             }
[01:29:27.961]         }))
[01:29:27.961]     }, error = function(ex) {
[01:29:27.961]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.961]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.961]                 ...future.rng), started = ...future.startTime, 
[01:29:27.961]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.961]             version = "1.8"), class = "FutureResult")
[01:29:27.961]     }, finally = {
[01:29:27.961]         if (!identical(...future.workdir, getwd())) 
[01:29:27.961]             setwd(...future.workdir)
[01:29:27.961]         {
[01:29:27.961]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.961]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.961]             }
[01:29:27.961]             base::options(...future.oldOptions)
[01:29:27.961]             if (.Platform$OS.type == "windows") {
[01:29:27.961]                 old_names <- names(...future.oldEnvVars)
[01:29:27.961]                 envs <- base::Sys.getenv()
[01:29:27.961]                 names <- names(envs)
[01:29:27.961]                 common <- intersect(names, old_names)
[01:29:27.961]                 added <- setdiff(names, old_names)
[01:29:27.961]                 removed <- setdiff(old_names, names)
[01:29:27.961]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.961]                   envs[common]]
[01:29:27.961]                 NAMES <- toupper(changed)
[01:29:27.961]                 args <- list()
[01:29:27.961]                 for (kk in seq_along(NAMES)) {
[01:29:27.961]                   name <- changed[[kk]]
[01:29:27.961]                   NAME <- NAMES[[kk]]
[01:29:27.961]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.961]                     next
[01:29:27.961]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.961]                 }
[01:29:27.961]                 NAMES <- toupper(added)
[01:29:27.961]                 for (kk in seq_along(NAMES)) {
[01:29:27.961]                   name <- added[[kk]]
[01:29:27.961]                   NAME <- NAMES[[kk]]
[01:29:27.961]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.961]                     next
[01:29:27.961]                   args[[name]] <- ""
[01:29:27.961]                 }
[01:29:27.961]                 NAMES <- toupper(removed)
[01:29:27.961]                 for (kk in seq_along(NAMES)) {
[01:29:27.961]                   name <- removed[[kk]]
[01:29:27.961]                   NAME <- NAMES[[kk]]
[01:29:27.961]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.961]                     next
[01:29:27.961]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.961]                 }
[01:29:27.961]                 if (length(args) > 0) 
[01:29:27.961]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.961]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.961]             }
[01:29:27.961]             else {
[01:29:27.961]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.961]             }
[01:29:27.961]             {
[01:29:27.961]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.961]                   0L) {
[01:29:27.961]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.961]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.961]                   base::options(opts)
[01:29:27.961]                 }
[01:29:27.961]                 {
[01:29:27.961]                   {
[01:29:27.961]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:27.961]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:27.961]                     -1344458670L), envir = base::globalenv(), 
[01:29:27.961]                       inherits = FALSE)
[01:29:27.961]                     NULL
[01:29:27.961]                   }
[01:29:27.961]                   options(future.plan = NULL)
[01:29:27.961]                   if (is.na(NA_character_)) 
[01:29:27.961]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.961]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.961]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.961]                   {
[01:29:27.961]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.961]                     if (!future$lazy) 
[01:29:27.961]                       future <- run(future)
[01:29:27.961]                     invisible(future)
[01:29:27.961]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.961]                 }
[01:29:27.961]             }
[01:29:27.961]         }
[01:29:27.961]     })
[01:29:27.961]     if (TRUE) {
[01:29:27.961]         base::sink(type = "output", split = FALSE)
[01:29:27.961]         if (TRUE) {
[01:29:27.961]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.961]         }
[01:29:27.961]         else {
[01:29:27.961]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.961]         }
[01:29:27.961]         base::close(...future.stdout)
[01:29:27.961]         ...future.stdout <- NULL
[01:29:27.961]     }
[01:29:27.961]     ...future.result$conditions <- ...future.conditions
[01:29:27.961]     ...future.result$finished <- base::Sys.time()
[01:29:27.961]     ...future.result
[01:29:27.961] }
[01:29:27.965] assign_globals() ...
[01:29:27.965] List of 1
[01:29:27.965]  $ x: int [1:4] 0 1 2 3
[01:29:27.965]  - attr(*, "where")=List of 1
[01:29:27.965]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.965]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.965]  - attr(*, "resolved")= logi FALSE
[01:29:27.965]  - attr(*, "total_size")= num 64
[01:29:27.965]  - attr(*, "already-done")= logi TRUE
[01:29:27.969] - copied 'x' to environment
[01:29:27.969] assign_globals() ... done
[01:29:27.969] plan(): Setting new future strategy stack:
[01:29:27.969] List of future strategies:
[01:29:27.969] 1. sequential:
[01:29:27.969]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.969]    - tweaked: FALSE
[01:29:27.969]    - call: NULL
[01:29:27.970] plan(): nbrOfWorkers() = 1
[01:29:27.971] plan(): Setting new future strategy stack:
[01:29:27.971] List of future strategies:
[01:29:27.971] 1. sequential:
[01:29:27.971]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.971]    - tweaked: FALSE
[01:29:27.971]    - call: plan(strategy)
[01:29:27.972] plan(): nbrOfWorkers() = 1
[01:29:27.972] SequentialFuture started (and completed)
[01:29:27.972] - Launch lazy future ... done
[01:29:27.973] run() for 'SequentialFuture' ... done
[01:29:27.973] getGlobalsAndPackages() ...
[01:29:27.973] Searching for globals...
[01:29:27.974] - globals found: [3] '{', 'sample', 'x'
[01:29:27.975] Searching for globals ... DONE
[01:29:27.975] Resolving globals: FALSE
[01:29:27.975] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.976] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.976] - globals: [1] 'x'
[01:29:27.976] 
[01:29:27.976] getGlobalsAndPackages() ... DONE
[01:29:27.977] run() for 'Future' ...
[01:29:27.977] - state: 'created'
[01:29:27.977] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:27.977] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:27.978] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:27.978]   - Field: 'label'
[01:29:27.978]   - Field: 'local'
[01:29:27.978]   - Field: 'owner'
[01:29:27.978]   - Field: 'envir'
[01:29:27.978]   - Field: 'packages'
[01:29:27.979]   - Field: 'gc'
[01:29:27.979]   - Field: 'conditions'
[01:29:27.980]   - Field: 'expr'
[01:29:27.980]   - Field: 'uuid'
[01:29:27.980]   - Field: 'seed'
[01:29:27.981]   - Field: 'version'
[01:29:27.981]   - Field: 'result'
[01:29:27.981]   - Field: 'asynchronous'
[01:29:27.981]   - Field: 'calls'
[01:29:27.981]   - Field: 'globals'
[01:29:27.982]   - Field: 'stdout'
[01:29:27.982]   - Field: 'earlySignal'
[01:29:27.982]   - Field: 'lazy'
[01:29:27.982]   - Field: 'state'
[01:29:27.982] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:27.982] - Launch lazy future ...
[01:29:27.983] Packages needed by the future expression (n = 0): <none>
[01:29:27.983] Packages needed by future strategies (n = 0): <none>
[01:29:27.983] {
[01:29:27.983]     {
[01:29:27.983]         {
[01:29:27.983]             ...future.startTime <- base::Sys.time()
[01:29:27.983]             {
[01:29:27.983]                 {
[01:29:27.983]                   {
[01:29:27.983]                     {
[01:29:27.983]                       base::local({
[01:29:27.983]                         has_future <- base::requireNamespace("future", 
[01:29:27.983]                           quietly = TRUE)
[01:29:27.983]                         if (has_future) {
[01:29:27.983]                           ns <- base::getNamespace("future")
[01:29:27.983]                           version <- ns[[".package"]][["version"]]
[01:29:27.983]                           if (is.null(version)) 
[01:29:27.983]                             version <- utils::packageVersion("future")
[01:29:27.983]                         }
[01:29:27.983]                         else {
[01:29:27.983]                           version <- NULL
[01:29:27.983]                         }
[01:29:27.983]                         if (!has_future || version < "1.8.0") {
[01:29:27.983]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:27.983]                             "", base::R.version$version.string), 
[01:29:27.983]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:27.983]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:27.983]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:27.983]                               "release", "version")], collapse = " "), 
[01:29:27.983]                             hostname = base::Sys.info()[["nodename"]])
[01:29:27.983]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:27.983]                             info)
[01:29:27.983]                           info <- base::paste(info, collapse = "; ")
[01:29:27.983]                           if (!has_future) {
[01:29:27.983]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:27.983]                               info)
[01:29:27.983]                           }
[01:29:27.983]                           else {
[01:29:27.983]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:27.983]                               info, version)
[01:29:27.983]                           }
[01:29:27.983]                           base::stop(msg)
[01:29:27.983]                         }
[01:29:27.983]                       })
[01:29:27.983]                     }
[01:29:27.983]                     options(future.plan = NULL)
[01:29:27.983]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.983]                     future::plan("default", .cleanup = FALSE, 
[01:29:27.983]                       .init = FALSE)
[01:29:27.983]                   }
[01:29:27.983]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[01:29:27.983]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[01:29:27.983]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[01:29:27.983]                 }
[01:29:27.983]                 ...future.workdir <- getwd()
[01:29:27.983]             }
[01:29:27.983]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:27.983]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:27.983]         }
[01:29:27.983]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:27.983]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:27.983]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:27.983]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:27.983]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:27.983]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:27.983]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:27.983]             base::names(...future.oldOptions))
[01:29:27.983]     }
[01:29:27.983]     if (FALSE) {
[01:29:27.983]     }
[01:29:27.983]     else {
[01:29:27.983]         if (TRUE) {
[01:29:27.983]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:27.983]                 open = "w")
[01:29:27.983]         }
[01:29:27.983]         else {
[01:29:27.983]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:27.983]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:27.983]         }
[01:29:27.983]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:27.983]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:27.983]             base::sink(type = "output", split = FALSE)
[01:29:27.983]             base::close(...future.stdout)
[01:29:27.983]         }, add = TRUE)
[01:29:27.983]     }
[01:29:27.983]     ...future.frame <- base::sys.nframe()
[01:29:27.983]     ...future.conditions <- base::list()
[01:29:27.983]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:27.983]     if (FALSE) {
[01:29:27.983]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:27.983]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:27.983]     }
[01:29:27.983]     ...future.result <- base::tryCatch({
[01:29:27.983]         base::withCallingHandlers({
[01:29:27.983]             ...future.value <- base::withVisible(base::local({
[01:29:27.983]                 sample(x, size = 1L)
[01:29:27.983]             }))
[01:29:27.983]             future::FutureResult(value = ...future.value$value, 
[01:29:27.983]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.983]                   ...future.rng), globalenv = if (FALSE) 
[01:29:27.983]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:27.983]                     ...future.globalenv.names))
[01:29:27.983]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:27.983]         }, condition = base::local({
[01:29:27.983]             c <- base::c
[01:29:27.983]             inherits <- base::inherits
[01:29:27.983]             invokeRestart <- base::invokeRestart
[01:29:27.983]             length <- base::length
[01:29:27.983]             list <- base::list
[01:29:27.983]             seq.int <- base::seq.int
[01:29:27.983]             signalCondition <- base::signalCondition
[01:29:27.983]             sys.calls <- base::sys.calls
[01:29:27.983]             `[[` <- base::`[[`
[01:29:27.983]             `+` <- base::`+`
[01:29:27.983]             `<<-` <- base::`<<-`
[01:29:27.983]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:27.983]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:27.983]                   3L)]
[01:29:27.983]             }
[01:29:27.983]             function(cond) {
[01:29:27.983]                 is_error <- inherits(cond, "error")
[01:29:27.983]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:27.983]                   NULL)
[01:29:27.983]                 if (is_error) {
[01:29:27.983]                   sessionInformation <- function() {
[01:29:27.983]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:27.983]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:27.983]                       search = base::search(), system = base::Sys.info())
[01:29:27.983]                   }
[01:29:27.983]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.983]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:27.983]                     cond$call), session = sessionInformation(), 
[01:29:27.983]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:27.983]                   signalCondition(cond)
[01:29:27.983]                 }
[01:29:27.983]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:27.983]                 "immediateCondition"))) {
[01:29:27.983]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:27.983]                   ...future.conditions[[length(...future.conditions) + 
[01:29:27.983]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:27.983]                   if (TRUE && !signal) {
[01:29:27.983]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.983]                     {
[01:29:27.983]                       inherits <- base::inherits
[01:29:27.983]                       invokeRestart <- base::invokeRestart
[01:29:27.983]                       is.null <- base::is.null
[01:29:27.983]                       muffled <- FALSE
[01:29:27.983]                       if (inherits(cond, "message")) {
[01:29:27.983]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.983]                         if (muffled) 
[01:29:27.983]                           invokeRestart("muffleMessage")
[01:29:27.983]                       }
[01:29:27.983]                       else if (inherits(cond, "warning")) {
[01:29:27.983]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.983]                         if (muffled) 
[01:29:27.983]                           invokeRestart("muffleWarning")
[01:29:27.983]                       }
[01:29:27.983]                       else if (inherits(cond, "condition")) {
[01:29:27.983]                         if (!is.null(pattern)) {
[01:29:27.983]                           computeRestarts <- base::computeRestarts
[01:29:27.983]                           grepl <- base::grepl
[01:29:27.983]                           restarts <- computeRestarts(cond)
[01:29:27.983]                           for (restart in restarts) {
[01:29:27.983]                             name <- restart$name
[01:29:27.983]                             if (is.null(name)) 
[01:29:27.983]                               next
[01:29:27.983]                             if (!grepl(pattern, name)) 
[01:29:27.983]                               next
[01:29:27.983]                             invokeRestart(restart)
[01:29:27.983]                             muffled <- TRUE
[01:29:27.983]                             break
[01:29:27.983]                           }
[01:29:27.983]                         }
[01:29:27.983]                       }
[01:29:27.983]                       invisible(muffled)
[01:29:27.983]                     }
[01:29:27.983]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.983]                   }
[01:29:27.983]                 }
[01:29:27.983]                 else {
[01:29:27.983]                   if (TRUE) {
[01:29:27.983]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:27.983]                     {
[01:29:27.983]                       inherits <- base::inherits
[01:29:27.983]                       invokeRestart <- base::invokeRestart
[01:29:27.983]                       is.null <- base::is.null
[01:29:27.983]                       muffled <- FALSE
[01:29:27.983]                       if (inherits(cond, "message")) {
[01:29:27.983]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:27.983]                         if (muffled) 
[01:29:27.983]                           invokeRestart("muffleMessage")
[01:29:27.983]                       }
[01:29:27.983]                       else if (inherits(cond, "warning")) {
[01:29:27.983]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:27.983]                         if (muffled) 
[01:29:27.983]                           invokeRestart("muffleWarning")
[01:29:27.983]                       }
[01:29:27.983]                       else if (inherits(cond, "condition")) {
[01:29:27.983]                         if (!is.null(pattern)) {
[01:29:27.983]                           computeRestarts <- base::computeRestarts
[01:29:27.983]                           grepl <- base::grepl
[01:29:27.983]                           restarts <- computeRestarts(cond)
[01:29:27.983]                           for (restart in restarts) {
[01:29:27.983]                             name <- restart$name
[01:29:27.983]                             if (is.null(name)) 
[01:29:27.983]                               next
[01:29:27.983]                             if (!grepl(pattern, name)) 
[01:29:27.983]                               next
[01:29:27.983]                             invokeRestart(restart)
[01:29:27.983]                             muffled <- TRUE
[01:29:27.983]                             break
[01:29:27.983]                           }
[01:29:27.983]                         }
[01:29:27.983]                       }
[01:29:27.983]                       invisible(muffled)
[01:29:27.983]                     }
[01:29:27.983]                     muffleCondition(cond, pattern = "^muffle")
[01:29:27.983]                   }
[01:29:27.983]                 }
[01:29:27.983]             }
[01:29:27.983]         }))
[01:29:27.983]     }, error = function(ex) {
[01:29:27.983]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:27.983]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:27.983]                 ...future.rng), started = ...future.startTime, 
[01:29:27.983]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:27.983]             version = "1.8"), class = "FutureResult")
[01:29:27.983]     }, finally = {
[01:29:27.983]         if (!identical(...future.workdir, getwd())) 
[01:29:27.983]             setwd(...future.workdir)
[01:29:27.983]         {
[01:29:27.983]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:27.983]                 ...future.oldOptions$nwarnings <- NULL
[01:29:27.983]             }
[01:29:27.983]             base::options(...future.oldOptions)
[01:29:27.983]             if (.Platform$OS.type == "windows") {
[01:29:27.983]                 old_names <- names(...future.oldEnvVars)
[01:29:27.983]                 envs <- base::Sys.getenv()
[01:29:27.983]                 names <- names(envs)
[01:29:27.983]                 common <- intersect(names, old_names)
[01:29:27.983]                 added <- setdiff(names, old_names)
[01:29:27.983]                 removed <- setdiff(old_names, names)
[01:29:27.983]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:27.983]                   envs[common]]
[01:29:27.983]                 NAMES <- toupper(changed)
[01:29:27.983]                 args <- list()
[01:29:27.983]                 for (kk in seq_along(NAMES)) {
[01:29:27.983]                   name <- changed[[kk]]
[01:29:27.983]                   NAME <- NAMES[[kk]]
[01:29:27.983]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.983]                     next
[01:29:27.983]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.983]                 }
[01:29:27.983]                 NAMES <- toupper(added)
[01:29:27.983]                 for (kk in seq_along(NAMES)) {
[01:29:27.983]                   name <- added[[kk]]
[01:29:27.983]                   NAME <- NAMES[[kk]]
[01:29:27.983]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.983]                     next
[01:29:27.983]                   args[[name]] <- ""
[01:29:27.983]                 }
[01:29:27.983]                 NAMES <- toupper(removed)
[01:29:27.983]                 for (kk in seq_along(NAMES)) {
[01:29:27.983]                   name <- removed[[kk]]
[01:29:27.983]                   NAME <- NAMES[[kk]]
[01:29:27.983]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:27.983]                     next
[01:29:27.983]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:27.983]                 }
[01:29:27.983]                 if (length(args) > 0) 
[01:29:27.983]                   base::do.call(base::Sys.setenv, args = args)
[01:29:27.983]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:27.983]             }
[01:29:27.983]             else {
[01:29:27.983]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:27.983]             }
[01:29:27.983]             {
[01:29:27.983]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:27.983]                   0L) {
[01:29:27.983]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:27.983]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:27.983]                   base::options(opts)
[01:29:27.983]                 }
[01:29:27.983]                 {
[01:29:27.983]                   {
[01:29:27.983]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[01:29:27.983]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[01:29:27.983]                     -1344458670L), envir = base::globalenv(), 
[01:29:27.983]                       inherits = FALSE)
[01:29:27.983]                     NULL
[01:29:27.983]                   }
[01:29:27.983]                   options(future.plan = NULL)
[01:29:27.983]                   if (is.na(NA_character_)) 
[01:29:27.983]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:27.983]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:27.983]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:27.983]                   {
[01:29:27.983]                     future <- SequentialFuture(..., envir = envir)
[01:29:27.983]                     if (!future$lazy) 
[01:29:27.983]                       future <- run(future)
[01:29:27.983]                     invisible(future)
[01:29:27.983]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:27.983]                 }
[01:29:27.983]             }
[01:29:27.983]         }
[01:29:27.983]     })
[01:29:27.983]     if (TRUE) {
[01:29:27.983]         base::sink(type = "output", split = FALSE)
[01:29:27.983]         if (TRUE) {
[01:29:27.983]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:27.983]         }
[01:29:27.983]         else {
[01:29:27.983]             ...future.result["stdout"] <- base::list(NULL)
[01:29:27.983]         }
[01:29:27.983]         base::close(...future.stdout)
[01:29:27.983]         ...future.stdout <- NULL
[01:29:27.983]     }
[01:29:27.983]     ...future.result$conditions <- ...future.conditions
[01:29:27.983]     ...future.result$finished <- base::Sys.time()
[01:29:27.983]     ...future.result
[01:29:27.983] }
[01:29:27.988] assign_globals() ...
[01:29:27.988] List of 1
[01:29:27.988]  $ x: int [1:4] 0 1 2 3
[01:29:27.988]  - attr(*, "where")=List of 1
[01:29:27.988]   ..$ x:<environment: R_EmptyEnv> 
[01:29:27.988]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:27.988]  - attr(*, "resolved")= logi FALSE
[01:29:27.988]  - attr(*, "total_size")= num 64
[01:29:27.988]  - attr(*, "already-done")= logi TRUE
[01:29:27.991] - copied 'x' to environment
[01:29:27.991] assign_globals() ... done
[01:29:27.991] plan(): Setting new future strategy stack:
[01:29:27.992] List of future strategies:
[01:29:27.992] 1. sequential:
[01:29:27.992]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.992]    - tweaked: FALSE
[01:29:27.992]    - call: NULL
[01:29:27.992] plan(): nbrOfWorkers() = 1
[01:29:27.993] plan(): Setting new future strategy stack:
[01:29:27.994] List of future strategies:
[01:29:27.994] 1. sequential:
[01:29:27.994]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:27.994]    - tweaked: FALSE
[01:29:27.994]    - call: plan(strategy)
[01:29:27.994] plan(): nbrOfWorkers() = 1
[01:29:27.994] SequentialFuture started (and completed)
[01:29:27.995] - Launch lazy future ... done
[01:29:27.995] run() for 'SequentialFuture' ... done
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[01:29:27.996] getGlobalsAndPackages() ...
[01:29:27.996] Searching for globals...
[01:29:27.997] - globals found: [3] '{', 'sample', 'x'
[01:29:27.997] Searching for globals ... DONE
[01:29:27.998] Resolving globals: FALSE
[01:29:27.998] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:27.999] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:27.999] - globals: [1] 'x'
[01:29:27.999] 
[01:29:27.999] getGlobalsAndPackages() ... DONE
[01:29:27.999] run() for 'Future' ...
[01:29:28.000] - state: 'created'
[01:29:28.000] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.000] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.000] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.000]   - Field: 'label'
[01:29:28.001]   - Field: 'local'
[01:29:28.001]   - Field: 'owner'
[01:29:28.001]   - Field: 'envir'
[01:29:28.001]   - Field: 'packages'
[01:29:28.001]   - Field: 'gc'
[01:29:28.002]   - Field: 'conditions'
[01:29:28.002]   - Field: 'expr'
[01:29:28.002]   - Field: 'uuid'
[01:29:28.002]   - Field: 'seed'
[01:29:28.002]   - Field: 'version'
[01:29:28.003]   - Field: 'result'
[01:29:28.003]   - Field: 'asynchronous'
[01:29:28.003]   - Field: 'calls'
[01:29:28.003]   - Field: 'globals'
[01:29:28.003]   - Field: 'stdout'
[01:29:28.003]   - Field: 'earlySignal'
[01:29:28.004]   - Field: 'lazy'
[01:29:28.004]   - Field: 'state'
[01:29:28.004] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.004] - Launch lazy future ...
[01:29:28.004] Packages needed by the future expression (n = 0): <none>
[01:29:28.005] Packages needed by future strategies (n = 0): <none>
[01:29:28.005] {
[01:29:28.005]     {
[01:29:28.005]         {
[01:29:28.005]             ...future.startTime <- base::Sys.time()
[01:29:28.005]             {
[01:29:28.005]                 {
[01:29:28.005]                   {
[01:29:28.005]                     base::local({
[01:29:28.005]                       has_future <- base::requireNamespace("future", 
[01:29:28.005]                         quietly = TRUE)
[01:29:28.005]                       if (has_future) {
[01:29:28.005]                         ns <- base::getNamespace("future")
[01:29:28.005]                         version <- ns[[".package"]][["version"]]
[01:29:28.005]                         if (is.null(version)) 
[01:29:28.005]                           version <- utils::packageVersion("future")
[01:29:28.005]                       }
[01:29:28.005]                       else {
[01:29:28.005]                         version <- NULL
[01:29:28.005]                       }
[01:29:28.005]                       if (!has_future || version < "1.8.0") {
[01:29:28.005]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.005]                           "", base::R.version$version.string), 
[01:29:28.005]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.005]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.005]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.005]                             "release", "version")], collapse = " "), 
[01:29:28.005]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.005]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.005]                           info)
[01:29:28.005]                         info <- base::paste(info, collapse = "; ")
[01:29:28.005]                         if (!has_future) {
[01:29:28.005]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.005]                             info)
[01:29:28.005]                         }
[01:29:28.005]                         else {
[01:29:28.005]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.005]                             info, version)
[01:29:28.005]                         }
[01:29:28.005]                         base::stop(msg)
[01:29:28.005]                       }
[01:29:28.005]                     })
[01:29:28.005]                   }
[01:29:28.005]                   options(future.plan = NULL)
[01:29:28.005]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.005]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.005]                 }
[01:29:28.005]                 ...future.workdir <- getwd()
[01:29:28.005]             }
[01:29:28.005]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.005]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.005]         }
[01:29:28.005]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.005]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.005]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.005]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.005]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.005]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.005]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.005]             base::names(...future.oldOptions))
[01:29:28.005]     }
[01:29:28.005]     if (FALSE) {
[01:29:28.005]     }
[01:29:28.005]     else {
[01:29:28.005]         if (TRUE) {
[01:29:28.005]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.005]                 open = "w")
[01:29:28.005]         }
[01:29:28.005]         else {
[01:29:28.005]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.005]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.005]         }
[01:29:28.005]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.005]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.005]             base::sink(type = "output", split = FALSE)
[01:29:28.005]             base::close(...future.stdout)
[01:29:28.005]         }, add = TRUE)
[01:29:28.005]     }
[01:29:28.005]     ...future.frame <- base::sys.nframe()
[01:29:28.005]     ...future.conditions <- base::list()
[01:29:28.005]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.005]     if (FALSE) {
[01:29:28.005]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.005]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.005]     }
[01:29:28.005]     ...future.result <- base::tryCatch({
[01:29:28.005]         base::withCallingHandlers({
[01:29:28.005]             ...future.value <- base::withVisible(base::local({
[01:29:28.005]                 sample(x, size = 1L)
[01:29:28.005]             }))
[01:29:28.005]             future::FutureResult(value = ...future.value$value, 
[01:29:28.005]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.005]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.005]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.005]                     ...future.globalenv.names))
[01:29:28.005]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.005]         }, condition = base::local({
[01:29:28.005]             c <- base::c
[01:29:28.005]             inherits <- base::inherits
[01:29:28.005]             invokeRestart <- base::invokeRestart
[01:29:28.005]             length <- base::length
[01:29:28.005]             list <- base::list
[01:29:28.005]             seq.int <- base::seq.int
[01:29:28.005]             signalCondition <- base::signalCondition
[01:29:28.005]             sys.calls <- base::sys.calls
[01:29:28.005]             `[[` <- base::`[[`
[01:29:28.005]             `+` <- base::`+`
[01:29:28.005]             `<<-` <- base::`<<-`
[01:29:28.005]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.005]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.005]                   3L)]
[01:29:28.005]             }
[01:29:28.005]             function(cond) {
[01:29:28.005]                 is_error <- inherits(cond, "error")
[01:29:28.005]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.005]                   NULL)
[01:29:28.005]                 if (is_error) {
[01:29:28.005]                   sessionInformation <- function() {
[01:29:28.005]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.005]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.005]                       search = base::search(), system = base::Sys.info())
[01:29:28.005]                   }
[01:29:28.005]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.005]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.005]                     cond$call), session = sessionInformation(), 
[01:29:28.005]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.005]                   signalCondition(cond)
[01:29:28.005]                 }
[01:29:28.005]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.005]                 "immediateCondition"))) {
[01:29:28.005]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.005]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.005]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.005]                   if (TRUE && !signal) {
[01:29:28.005]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.005]                     {
[01:29:28.005]                       inherits <- base::inherits
[01:29:28.005]                       invokeRestart <- base::invokeRestart
[01:29:28.005]                       is.null <- base::is.null
[01:29:28.005]                       muffled <- FALSE
[01:29:28.005]                       if (inherits(cond, "message")) {
[01:29:28.005]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.005]                         if (muffled) 
[01:29:28.005]                           invokeRestart("muffleMessage")
[01:29:28.005]                       }
[01:29:28.005]                       else if (inherits(cond, "warning")) {
[01:29:28.005]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.005]                         if (muffled) 
[01:29:28.005]                           invokeRestart("muffleWarning")
[01:29:28.005]                       }
[01:29:28.005]                       else if (inherits(cond, "condition")) {
[01:29:28.005]                         if (!is.null(pattern)) {
[01:29:28.005]                           computeRestarts <- base::computeRestarts
[01:29:28.005]                           grepl <- base::grepl
[01:29:28.005]                           restarts <- computeRestarts(cond)
[01:29:28.005]                           for (restart in restarts) {
[01:29:28.005]                             name <- restart$name
[01:29:28.005]                             if (is.null(name)) 
[01:29:28.005]                               next
[01:29:28.005]                             if (!grepl(pattern, name)) 
[01:29:28.005]                               next
[01:29:28.005]                             invokeRestart(restart)
[01:29:28.005]                             muffled <- TRUE
[01:29:28.005]                             break
[01:29:28.005]                           }
[01:29:28.005]                         }
[01:29:28.005]                       }
[01:29:28.005]                       invisible(muffled)
[01:29:28.005]                     }
[01:29:28.005]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.005]                   }
[01:29:28.005]                 }
[01:29:28.005]                 else {
[01:29:28.005]                   if (TRUE) {
[01:29:28.005]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.005]                     {
[01:29:28.005]                       inherits <- base::inherits
[01:29:28.005]                       invokeRestart <- base::invokeRestart
[01:29:28.005]                       is.null <- base::is.null
[01:29:28.005]                       muffled <- FALSE
[01:29:28.005]                       if (inherits(cond, "message")) {
[01:29:28.005]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.005]                         if (muffled) 
[01:29:28.005]                           invokeRestart("muffleMessage")
[01:29:28.005]                       }
[01:29:28.005]                       else if (inherits(cond, "warning")) {
[01:29:28.005]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.005]                         if (muffled) 
[01:29:28.005]                           invokeRestart("muffleWarning")
[01:29:28.005]                       }
[01:29:28.005]                       else if (inherits(cond, "condition")) {
[01:29:28.005]                         if (!is.null(pattern)) {
[01:29:28.005]                           computeRestarts <- base::computeRestarts
[01:29:28.005]                           grepl <- base::grepl
[01:29:28.005]                           restarts <- computeRestarts(cond)
[01:29:28.005]                           for (restart in restarts) {
[01:29:28.005]                             name <- restart$name
[01:29:28.005]                             if (is.null(name)) 
[01:29:28.005]                               next
[01:29:28.005]                             if (!grepl(pattern, name)) 
[01:29:28.005]                               next
[01:29:28.005]                             invokeRestart(restart)
[01:29:28.005]                             muffled <- TRUE
[01:29:28.005]                             break
[01:29:28.005]                           }
[01:29:28.005]                         }
[01:29:28.005]                       }
[01:29:28.005]                       invisible(muffled)
[01:29:28.005]                     }
[01:29:28.005]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.005]                   }
[01:29:28.005]                 }
[01:29:28.005]             }
[01:29:28.005]         }))
[01:29:28.005]     }, error = function(ex) {
[01:29:28.005]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.005]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.005]                 ...future.rng), started = ...future.startTime, 
[01:29:28.005]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.005]             version = "1.8"), class = "FutureResult")
[01:29:28.005]     }, finally = {
[01:29:28.005]         if (!identical(...future.workdir, getwd())) 
[01:29:28.005]             setwd(...future.workdir)
[01:29:28.005]         {
[01:29:28.005]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.005]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.005]             }
[01:29:28.005]             base::options(...future.oldOptions)
[01:29:28.005]             if (.Platform$OS.type == "windows") {
[01:29:28.005]                 old_names <- names(...future.oldEnvVars)
[01:29:28.005]                 envs <- base::Sys.getenv()
[01:29:28.005]                 names <- names(envs)
[01:29:28.005]                 common <- intersect(names, old_names)
[01:29:28.005]                 added <- setdiff(names, old_names)
[01:29:28.005]                 removed <- setdiff(old_names, names)
[01:29:28.005]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.005]                   envs[common]]
[01:29:28.005]                 NAMES <- toupper(changed)
[01:29:28.005]                 args <- list()
[01:29:28.005]                 for (kk in seq_along(NAMES)) {
[01:29:28.005]                   name <- changed[[kk]]
[01:29:28.005]                   NAME <- NAMES[[kk]]
[01:29:28.005]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.005]                     next
[01:29:28.005]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.005]                 }
[01:29:28.005]                 NAMES <- toupper(added)
[01:29:28.005]                 for (kk in seq_along(NAMES)) {
[01:29:28.005]                   name <- added[[kk]]
[01:29:28.005]                   NAME <- NAMES[[kk]]
[01:29:28.005]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.005]                     next
[01:29:28.005]                   args[[name]] <- ""
[01:29:28.005]                 }
[01:29:28.005]                 NAMES <- toupper(removed)
[01:29:28.005]                 for (kk in seq_along(NAMES)) {
[01:29:28.005]                   name <- removed[[kk]]
[01:29:28.005]                   NAME <- NAMES[[kk]]
[01:29:28.005]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.005]                     next
[01:29:28.005]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.005]                 }
[01:29:28.005]                 if (length(args) > 0) 
[01:29:28.005]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.005]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.005]             }
[01:29:28.005]             else {
[01:29:28.005]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.005]             }
[01:29:28.005]             {
[01:29:28.005]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.005]                   0L) {
[01:29:28.005]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.005]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.005]                   base::options(opts)
[01:29:28.005]                 }
[01:29:28.005]                 {
[01:29:28.005]                   {
[01:29:28.005]                     base::assign(".Random.seed", c(10407L, 1785299503L, 
[01:29:28.005]                     125646157L, 735078412L, -1829064174L, -1260931822L, 
[01:29:28.005]                     -118514619L), envir = base::globalenv(), 
[01:29:28.005]                       inherits = FALSE)
[01:29:28.005]                     NULL
[01:29:28.005]                   }
[01:29:28.005]                   options(future.plan = NULL)
[01:29:28.005]                   if (is.na(NA_character_)) 
[01:29:28.005]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.005]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.005]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.005]                   {
[01:29:28.005]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.005]                     if (!future$lazy) 
[01:29:28.005]                       future <- run(future)
[01:29:28.005]                     invisible(future)
[01:29:28.005]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.005]                 }
[01:29:28.005]             }
[01:29:28.005]         }
[01:29:28.005]     })
[01:29:28.005]     if (TRUE) {
[01:29:28.005]         base::sink(type = "output", split = FALSE)
[01:29:28.005]         if (TRUE) {
[01:29:28.005]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.005]         }
[01:29:28.005]         else {
[01:29:28.005]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.005]         }
[01:29:28.005]         base::close(...future.stdout)
[01:29:28.005]         ...future.stdout <- NULL
[01:29:28.005]     }
[01:29:28.005]     ...future.result$conditions <- ...future.conditions
[01:29:28.005]     ...future.result$finished <- base::Sys.time()
[01:29:28.005]     ...future.result
[01:29:28.005] }
[01:29:28.009] assign_globals() ...
[01:29:28.009] List of 1
[01:29:28.009]  $ x: int [1:4] 0 1 2 3
[01:29:28.009]  - attr(*, "where")=List of 1
[01:29:28.009]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.009]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.009]  - attr(*, "resolved")= logi FALSE
[01:29:28.009]  - attr(*, "total_size")= num 64
[01:29:28.009]  - attr(*, "already-done")= logi TRUE
[01:29:28.012] - copied 'x' to environment
[01:29:28.012] assign_globals() ... done
[01:29:28.014] plan(): Setting new future strategy stack:
[01:29:28.014] List of future strategies:
[01:29:28.014] 1. sequential:
[01:29:28.014]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.014]    - tweaked: FALSE
[01:29:28.014]    - call: NULL
[01:29:28.015] plan(): nbrOfWorkers() = 1
[01:29:28.016] plan(): Setting new future strategy stack:
[01:29:28.016] List of future strategies:
[01:29:28.016] 1. sequential:
[01:29:28.016]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.016]    - tweaked: FALSE
[01:29:28.016]    - call: plan(strategy)
[01:29:28.017] plan(): nbrOfWorkers() = 1
[01:29:28.017] SequentialFuture started (and completed)
[01:29:28.019] - Launch lazy future ... done
[01:29:28.019] run() for 'SequentialFuture' ... done
[01:29:28.021] getGlobalsAndPackages() ...
[01:29:28.022] Searching for globals...
[01:29:28.026] - globals found: [3] '{', 'sample', 'x'
[01:29:28.026] Searching for globals ... DONE
[01:29:28.027] Resolving globals: FALSE
[01:29:28.028] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.029] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.030] - globals: [1] 'x'
[01:29:28.030] 
[01:29:28.030] getGlobalsAndPackages() ... DONE
[01:29:28.031] run() for 'Future' ...
[01:29:28.032] - state: 'created'
[01:29:28.032] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.033] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.033] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.034]   - Field: 'label'
[01:29:28.034]   - Field: 'local'
[01:29:28.035]   - Field: 'owner'
[01:29:28.035]   - Field: 'envir'
[01:29:28.035]   - Field: 'packages'
[01:29:28.036]   - Field: 'gc'
[01:29:28.036]   - Field: 'conditions'
[01:29:28.037]   - Field: 'expr'
[01:29:28.037]   - Field: 'uuid'
[01:29:28.037]   - Field: 'seed'
[01:29:28.038]   - Field: 'version'
[01:29:28.038]   - Field: 'result'
[01:29:28.039]   - Field: 'asynchronous'
[01:29:28.039]   - Field: 'calls'
[01:29:28.039]   - Field: 'globals'
[01:29:28.040]   - Field: 'stdout'
[01:29:28.040]   - Field: 'earlySignal'
[01:29:28.040]   - Field: 'lazy'
[01:29:28.041]   - Field: 'state'
[01:29:28.041] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.041] - Launch lazy future ...
[01:29:28.042] Packages needed by the future expression (n = 0): <none>
[01:29:28.042] Packages needed by future strategies (n = 0): <none>
[01:29:28.044] {
[01:29:28.044]     {
[01:29:28.044]         {
[01:29:28.044]             ...future.startTime <- base::Sys.time()
[01:29:28.044]             {
[01:29:28.044]                 {
[01:29:28.044]                   {
[01:29:28.044]                     base::local({
[01:29:28.044]                       has_future <- base::requireNamespace("future", 
[01:29:28.044]                         quietly = TRUE)
[01:29:28.044]                       if (has_future) {
[01:29:28.044]                         ns <- base::getNamespace("future")
[01:29:28.044]                         version <- ns[[".package"]][["version"]]
[01:29:28.044]                         if (is.null(version)) 
[01:29:28.044]                           version <- utils::packageVersion("future")
[01:29:28.044]                       }
[01:29:28.044]                       else {
[01:29:28.044]                         version <- NULL
[01:29:28.044]                       }
[01:29:28.044]                       if (!has_future || version < "1.8.0") {
[01:29:28.044]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.044]                           "", base::R.version$version.string), 
[01:29:28.044]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.044]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.044]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.044]                             "release", "version")], collapse = " "), 
[01:29:28.044]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.044]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.044]                           info)
[01:29:28.044]                         info <- base::paste(info, collapse = "; ")
[01:29:28.044]                         if (!has_future) {
[01:29:28.044]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.044]                             info)
[01:29:28.044]                         }
[01:29:28.044]                         else {
[01:29:28.044]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.044]                             info, version)
[01:29:28.044]                         }
[01:29:28.044]                         base::stop(msg)
[01:29:28.044]                       }
[01:29:28.044]                     })
[01:29:28.044]                   }
[01:29:28.044]                   options(future.plan = NULL)
[01:29:28.044]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.044]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.044]                 }
[01:29:28.044]                 ...future.workdir <- getwd()
[01:29:28.044]             }
[01:29:28.044]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.044]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.044]         }
[01:29:28.044]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.044]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.044]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.044]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.044]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.044]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.044]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.044]             base::names(...future.oldOptions))
[01:29:28.044]     }
[01:29:28.044]     if (FALSE) {
[01:29:28.044]     }
[01:29:28.044]     else {
[01:29:28.044]         if (TRUE) {
[01:29:28.044]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.044]                 open = "w")
[01:29:28.044]         }
[01:29:28.044]         else {
[01:29:28.044]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.044]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.044]         }
[01:29:28.044]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.044]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.044]             base::sink(type = "output", split = FALSE)
[01:29:28.044]             base::close(...future.stdout)
[01:29:28.044]         }, add = TRUE)
[01:29:28.044]     }
[01:29:28.044]     ...future.frame <- base::sys.nframe()
[01:29:28.044]     ...future.conditions <- base::list()
[01:29:28.044]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.044]     if (FALSE) {
[01:29:28.044]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.044]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.044]     }
[01:29:28.044]     ...future.result <- base::tryCatch({
[01:29:28.044]         base::withCallingHandlers({
[01:29:28.044]             ...future.value <- base::withVisible(base::local({
[01:29:28.044]                 sample(x, size = 1L)
[01:29:28.044]             }))
[01:29:28.044]             future::FutureResult(value = ...future.value$value, 
[01:29:28.044]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.044]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.044]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.044]                     ...future.globalenv.names))
[01:29:28.044]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.044]         }, condition = base::local({
[01:29:28.044]             c <- base::c
[01:29:28.044]             inherits <- base::inherits
[01:29:28.044]             invokeRestart <- base::invokeRestart
[01:29:28.044]             length <- base::length
[01:29:28.044]             list <- base::list
[01:29:28.044]             seq.int <- base::seq.int
[01:29:28.044]             signalCondition <- base::signalCondition
[01:29:28.044]             sys.calls <- base::sys.calls
[01:29:28.044]             `[[` <- base::`[[`
[01:29:28.044]             `+` <- base::`+`
[01:29:28.044]             `<<-` <- base::`<<-`
[01:29:28.044]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.044]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.044]                   3L)]
[01:29:28.044]             }
[01:29:28.044]             function(cond) {
[01:29:28.044]                 is_error <- inherits(cond, "error")
[01:29:28.044]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.044]                   NULL)
[01:29:28.044]                 if (is_error) {
[01:29:28.044]                   sessionInformation <- function() {
[01:29:28.044]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.044]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.044]                       search = base::search(), system = base::Sys.info())
[01:29:28.044]                   }
[01:29:28.044]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.044]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.044]                     cond$call), session = sessionInformation(), 
[01:29:28.044]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.044]                   signalCondition(cond)
[01:29:28.044]                 }
[01:29:28.044]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.044]                 "immediateCondition"))) {
[01:29:28.044]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.044]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.044]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.044]                   if (TRUE && !signal) {
[01:29:28.044]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.044]                     {
[01:29:28.044]                       inherits <- base::inherits
[01:29:28.044]                       invokeRestart <- base::invokeRestart
[01:29:28.044]                       is.null <- base::is.null
[01:29:28.044]                       muffled <- FALSE
[01:29:28.044]                       if (inherits(cond, "message")) {
[01:29:28.044]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.044]                         if (muffled) 
[01:29:28.044]                           invokeRestart("muffleMessage")
[01:29:28.044]                       }
[01:29:28.044]                       else if (inherits(cond, "warning")) {
[01:29:28.044]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.044]                         if (muffled) 
[01:29:28.044]                           invokeRestart("muffleWarning")
[01:29:28.044]                       }
[01:29:28.044]                       else if (inherits(cond, "condition")) {
[01:29:28.044]                         if (!is.null(pattern)) {
[01:29:28.044]                           computeRestarts <- base::computeRestarts
[01:29:28.044]                           grepl <- base::grepl
[01:29:28.044]                           restarts <- computeRestarts(cond)
[01:29:28.044]                           for (restart in restarts) {
[01:29:28.044]                             name <- restart$name
[01:29:28.044]                             if (is.null(name)) 
[01:29:28.044]                               next
[01:29:28.044]                             if (!grepl(pattern, name)) 
[01:29:28.044]                               next
[01:29:28.044]                             invokeRestart(restart)
[01:29:28.044]                             muffled <- TRUE
[01:29:28.044]                             break
[01:29:28.044]                           }
[01:29:28.044]                         }
[01:29:28.044]                       }
[01:29:28.044]                       invisible(muffled)
[01:29:28.044]                     }
[01:29:28.044]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.044]                   }
[01:29:28.044]                 }
[01:29:28.044]                 else {
[01:29:28.044]                   if (TRUE) {
[01:29:28.044]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.044]                     {
[01:29:28.044]                       inherits <- base::inherits
[01:29:28.044]                       invokeRestart <- base::invokeRestart
[01:29:28.044]                       is.null <- base::is.null
[01:29:28.044]                       muffled <- FALSE
[01:29:28.044]                       if (inherits(cond, "message")) {
[01:29:28.044]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.044]                         if (muffled) 
[01:29:28.044]                           invokeRestart("muffleMessage")
[01:29:28.044]                       }
[01:29:28.044]                       else if (inherits(cond, "warning")) {
[01:29:28.044]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.044]                         if (muffled) 
[01:29:28.044]                           invokeRestart("muffleWarning")
[01:29:28.044]                       }
[01:29:28.044]                       else if (inherits(cond, "condition")) {
[01:29:28.044]                         if (!is.null(pattern)) {
[01:29:28.044]                           computeRestarts <- base::computeRestarts
[01:29:28.044]                           grepl <- base::grepl
[01:29:28.044]                           restarts <- computeRestarts(cond)
[01:29:28.044]                           for (restart in restarts) {
[01:29:28.044]                             name <- restart$name
[01:29:28.044]                             if (is.null(name)) 
[01:29:28.044]                               next
[01:29:28.044]                             if (!grepl(pattern, name)) 
[01:29:28.044]                               next
[01:29:28.044]                             invokeRestart(restart)
[01:29:28.044]                             muffled <- TRUE
[01:29:28.044]                             break
[01:29:28.044]                           }
[01:29:28.044]                         }
[01:29:28.044]                       }
[01:29:28.044]                       invisible(muffled)
[01:29:28.044]                     }
[01:29:28.044]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.044]                   }
[01:29:28.044]                 }
[01:29:28.044]             }
[01:29:28.044]         }))
[01:29:28.044]     }, error = function(ex) {
[01:29:28.044]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.044]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.044]                 ...future.rng), started = ...future.startTime, 
[01:29:28.044]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.044]             version = "1.8"), class = "FutureResult")
[01:29:28.044]     }, finally = {
[01:29:28.044]         if (!identical(...future.workdir, getwd())) 
[01:29:28.044]             setwd(...future.workdir)
[01:29:28.044]         {
[01:29:28.044]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.044]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.044]             }
[01:29:28.044]             base::options(...future.oldOptions)
[01:29:28.044]             if (.Platform$OS.type == "windows") {
[01:29:28.044]                 old_names <- names(...future.oldEnvVars)
[01:29:28.044]                 envs <- base::Sys.getenv()
[01:29:28.044]                 names <- names(envs)
[01:29:28.044]                 common <- intersect(names, old_names)
[01:29:28.044]                 added <- setdiff(names, old_names)
[01:29:28.044]                 removed <- setdiff(old_names, names)
[01:29:28.044]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.044]                   envs[common]]
[01:29:28.044]                 NAMES <- toupper(changed)
[01:29:28.044]                 args <- list()
[01:29:28.044]                 for (kk in seq_along(NAMES)) {
[01:29:28.044]                   name <- changed[[kk]]
[01:29:28.044]                   NAME <- NAMES[[kk]]
[01:29:28.044]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.044]                     next
[01:29:28.044]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.044]                 }
[01:29:28.044]                 NAMES <- toupper(added)
[01:29:28.044]                 for (kk in seq_along(NAMES)) {
[01:29:28.044]                   name <- added[[kk]]
[01:29:28.044]                   NAME <- NAMES[[kk]]
[01:29:28.044]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.044]                     next
[01:29:28.044]                   args[[name]] <- ""
[01:29:28.044]                 }
[01:29:28.044]                 NAMES <- toupper(removed)
[01:29:28.044]                 for (kk in seq_along(NAMES)) {
[01:29:28.044]                   name <- removed[[kk]]
[01:29:28.044]                   NAME <- NAMES[[kk]]
[01:29:28.044]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.044]                     next
[01:29:28.044]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.044]                 }
[01:29:28.044]                 if (length(args) > 0) 
[01:29:28.044]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.044]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.044]             }
[01:29:28.044]             else {
[01:29:28.044]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.044]             }
[01:29:28.044]             {
[01:29:28.044]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.044]                   0L) {
[01:29:28.044]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.044]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.044]                   base::options(opts)
[01:29:28.044]                 }
[01:29:28.044]                 {
[01:29:28.044]                   {
[01:29:28.044]                     base::assign(".Random.seed", c(10407L, 735078412L, 
[01:29:28.044]                     1812399395L, -1054261393L, -118514619L, -1133846622L, 
[01:29:28.044]                     -881861939L), envir = base::globalenv(), 
[01:29:28.044]                       inherits = FALSE)
[01:29:28.044]                     NULL
[01:29:28.044]                   }
[01:29:28.044]                   options(future.plan = NULL)
[01:29:28.044]                   if (is.na(NA_character_)) 
[01:29:28.044]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.044]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.044]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.044]                   {
[01:29:28.044]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.044]                     if (!future$lazy) 
[01:29:28.044]                       future <- run(future)
[01:29:28.044]                     invisible(future)
[01:29:28.044]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.044]                 }
[01:29:28.044]             }
[01:29:28.044]         }
[01:29:28.044]     })
[01:29:28.044]     if (TRUE) {
[01:29:28.044]         base::sink(type = "output", split = FALSE)
[01:29:28.044]         if (TRUE) {
[01:29:28.044]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.044]         }
[01:29:28.044]         else {
[01:29:28.044]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.044]         }
[01:29:28.044]         base::close(...future.stdout)
[01:29:28.044]         ...future.stdout <- NULL
[01:29:28.044]     }
[01:29:28.044]     ...future.result$conditions <- ...future.conditions
[01:29:28.044]     ...future.result$finished <- base::Sys.time()
[01:29:28.044]     ...future.result
[01:29:28.044] }
[01:29:28.051] assign_globals() ...
[01:29:28.051] List of 1
[01:29:28.051]  $ x: int [1:4] 0 1 2 3
[01:29:28.051]  - attr(*, "where")=List of 1
[01:29:28.051]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.051]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.051]  - attr(*, "resolved")= logi FALSE
[01:29:28.051]  - attr(*, "total_size")= num 64
[01:29:28.051]  - attr(*, "already-done")= logi TRUE
[01:29:28.055] - copied 'x' to environment
[01:29:28.056] assign_globals() ... done
[01:29:28.056] plan(): Setting new future strategy stack:
[01:29:28.056] List of future strategies:
[01:29:28.056] 1. sequential:
[01:29:28.056]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.056]    - tweaked: FALSE
[01:29:28.056]    - call: NULL
[01:29:28.057] plan(): nbrOfWorkers() = 1
[01:29:28.059] plan(): Setting new future strategy stack:
[01:29:28.059] List of future strategies:
[01:29:28.059] 1. sequential:
[01:29:28.059]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.059]    - tweaked: FALSE
[01:29:28.059]    - call: plan(strategy)
[01:29:28.060] plan(): nbrOfWorkers() = 1
[01:29:28.060] SequentialFuture started (and completed)
[01:29:28.061] - Launch lazy future ... done
[01:29:28.061] run() for 'SequentialFuture' ... done
[01:29:28.062] getGlobalsAndPackages() ...
[01:29:28.062] Searching for globals...
[01:29:28.063] - globals found: [3] '{', 'sample', 'x'
[01:29:28.064] Searching for globals ... DONE
[01:29:28.064] Resolving globals: FALSE
[01:29:28.065] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.065] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.066] - globals: [1] 'x'
[01:29:28.066] 
[01:29:28.066] getGlobalsAndPackages() ... DONE
[01:29:28.066] run() for 'Future' ...
[01:29:28.067] - state: 'created'
[01:29:28.067] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.067] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.072] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.072]   - Field: 'label'
[01:29:28.072]   - Field: 'local'
[01:29:28.072]   - Field: 'owner'
[01:29:28.073]   - Field: 'envir'
[01:29:28.073]   - Field: 'packages'
[01:29:28.073]   - Field: 'gc'
[01:29:28.073]   - Field: 'conditions'
[01:29:28.074]   - Field: 'expr'
[01:29:28.074]   - Field: 'uuid'
[01:29:28.074]   - Field: 'seed'
[01:29:28.075]   - Field: 'version'
[01:29:28.075]   - Field: 'result'
[01:29:28.075]   - Field: 'asynchronous'
[01:29:28.075]   - Field: 'calls'
[01:29:28.075]   - Field: 'globals'
[01:29:28.076]   - Field: 'stdout'
[01:29:28.076]   - Field: 'earlySignal'
[01:29:28.076]   - Field: 'lazy'
[01:29:28.076]   - Field: 'state'
[01:29:28.077] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.077] - Launch lazy future ...
[01:29:28.077] Packages needed by the future expression (n = 0): <none>
[01:29:28.077] Packages needed by future strategies (n = 0): <none>
[01:29:28.078] {
[01:29:28.078]     {
[01:29:28.078]         {
[01:29:28.078]             ...future.startTime <- base::Sys.time()
[01:29:28.078]             {
[01:29:28.078]                 {
[01:29:28.078]                   {
[01:29:28.078]                     base::local({
[01:29:28.078]                       has_future <- base::requireNamespace("future", 
[01:29:28.078]                         quietly = TRUE)
[01:29:28.078]                       if (has_future) {
[01:29:28.078]                         ns <- base::getNamespace("future")
[01:29:28.078]                         version <- ns[[".package"]][["version"]]
[01:29:28.078]                         if (is.null(version)) 
[01:29:28.078]                           version <- utils::packageVersion("future")
[01:29:28.078]                       }
[01:29:28.078]                       else {
[01:29:28.078]                         version <- NULL
[01:29:28.078]                       }
[01:29:28.078]                       if (!has_future || version < "1.8.0") {
[01:29:28.078]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.078]                           "", base::R.version$version.string), 
[01:29:28.078]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.078]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.078]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.078]                             "release", "version")], collapse = " "), 
[01:29:28.078]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.078]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.078]                           info)
[01:29:28.078]                         info <- base::paste(info, collapse = "; ")
[01:29:28.078]                         if (!has_future) {
[01:29:28.078]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.078]                             info)
[01:29:28.078]                         }
[01:29:28.078]                         else {
[01:29:28.078]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.078]                             info, version)
[01:29:28.078]                         }
[01:29:28.078]                         base::stop(msg)
[01:29:28.078]                       }
[01:29:28.078]                     })
[01:29:28.078]                   }
[01:29:28.078]                   options(future.plan = NULL)
[01:29:28.078]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.078]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.078]                 }
[01:29:28.078]                 ...future.workdir <- getwd()
[01:29:28.078]             }
[01:29:28.078]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.078]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.078]         }
[01:29:28.078]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.078]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.078]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.078]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.078]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.078]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.078]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.078]             base::names(...future.oldOptions))
[01:29:28.078]     }
[01:29:28.078]     if (FALSE) {
[01:29:28.078]     }
[01:29:28.078]     else {
[01:29:28.078]         if (TRUE) {
[01:29:28.078]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.078]                 open = "w")
[01:29:28.078]         }
[01:29:28.078]         else {
[01:29:28.078]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.078]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.078]         }
[01:29:28.078]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.078]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.078]             base::sink(type = "output", split = FALSE)
[01:29:28.078]             base::close(...future.stdout)
[01:29:28.078]         }, add = TRUE)
[01:29:28.078]     }
[01:29:28.078]     ...future.frame <- base::sys.nframe()
[01:29:28.078]     ...future.conditions <- base::list()
[01:29:28.078]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.078]     if (FALSE) {
[01:29:28.078]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.078]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.078]     }
[01:29:28.078]     ...future.result <- base::tryCatch({
[01:29:28.078]         base::withCallingHandlers({
[01:29:28.078]             ...future.value <- base::withVisible(base::local({
[01:29:28.078]                 sample(x, size = 1L)
[01:29:28.078]             }))
[01:29:28.078]             future::FutureResult(value = ...future.value$value, 
[01:29:28.078]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.078]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.078]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.078]                     ...future.globalenv.names))
[01:29:28.078]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.078]         }, condition = base::local({
[01:29:28.078]             c <- base::c
[01:29:28.078]             inherits <- base::inherits
[01:29:28.078]             invokeRestart <- base::invokeRestart
[01:29:28.078]             length <- base::length
[01:29:28.078]             list <- base::list
[01:29:28.078]             seq.int <- base::seq.int
[01:29:28.078]             signalCondition <- base::signalCondition
[01:29:28.078]             sys.calls <- base::sys.calls
[01:29:28.078]             `[[` <- base::`[[`
[01:29:28.078]             `+` <- base::`+`
[01:29:28.078]             `<<-` <- base::`<<-`
[01:29:28.078]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.078]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.078]                   3L)]
[01:29:28.078]             }
[01:29:28.078]             function(cond) {
[01:29:28.078]                 is_error <- inherits(cond, "error")
[01:29:28.078]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.078]                   NULL)
[01:29:28.078]                 if (is_error) {
[01:29:28.078]                   sessionInformation <- function() {
[01:29:28.078]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.078]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.078]                       search = base::search(), system = base::Sys.info())
[01:29:28.078]                   }
[01:29:28.078]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.078]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.078]                     cond$call), session = sessionInformation(), 
[01:29:28.078]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.078]                   signalCondition(cond)
[01:29:28.078]                 }
[01:29:28.078]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.078]                 "immediateCondition"))) {
[01:29:28.078]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.078]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.078]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.078]                   if (TRUE && !signal) {
[01:29:28.078]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.078]                     {
[01:29:28.078]                       inherits <- base::inherits
[01:29:28.078]                       invokeRestart <- base::invokeRestart
[01:29:28.078]                       is.null <- base::is.null
[01:29:28.078]                       muffled <- FALSE
[01:29:28.078]                       if (inherits(cond, "message")) {
[01:29:28.078]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.078]                         if (muffled) 
[01:29:28.078]                           invokeRestart("muffleMessage")
[01:29:28.078]                       }
[01:29:28.078]                       else if (inherits(cond, "warning")) {
[01:29:28.078]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.078]                         if (muffled) 
[01:29:28.078]                           invokeRestart("muffleWarning")
[01:29:28.078]                       }
[01:29:28.078]                       else if (inherits(cond, "condition")) {
[01:29:28.078]                         if (!is.null(pattern)) {
[01:29:28.078]                           computeRestarts <- base::computeRestarts
[01:29:28.078]                           grepl <- base::grepl
[01:29:28.078]                           restarts <- computeRestarts(cond)
[01:29:28.078]                           for (restart in restarts) {
[01:29:28.078]                             name <- restart$name
[01:29:28.078]                             if (is.null(name)) 
[01:29:28.078]                               next
[01:29:28.078]                             if (!grepl(pattern, name)) 
[01:29:28.078]                               next
[01:29:28.078]                             invokeRestart(restart)
[01:29:28.078]                             muffled <- TRUE
[01:29:28.078]                             break
[01:29:28.078]                           }
[01:29:28.078]                         }
[01:29:28.078]                       }
[01:29:28.078]                       invisible(muffled)
[01:29:28.078]                     }
[01:29:28.078]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.078]                   }
[01:29:28.078]                 }
[01:29:28.078]                 else {
[01:29:28.078]                   if (TRUE) {
[01:29:28.078]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.078]                     {
[01:29:28.078]                       inherits <- base::inherits
[01:29:28.078]                       invokeRestart <- base::invokeRestart
[01:29:28.078]                       is.null <- base::is.null
[01:29:28.078]                       muffled <- FALSE
[01:29:28.078]                       if (inherits(cond, "message")) {
[01:29:28.078]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.078]                         if (muffled) 
[01:29:28.078]                           invokeRestart("muffleMessage")
[01:29:28.078]                       }
[01:29:28.078]                       else if (inherits(cond, "warning")) {
[01:29:28.078]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.078]                         if (muffled) 
[01:29:28.078]                           invokeRestart("muffleWarning")
[01:29:28.078]                       }
[01:29:28.078]                       else if (inherits(cond, "condition")) {
[01:29:28.078]                         if (!is.null(pattern)) {
[01:29:28.078]                           computeRestarts <- base::computeRestarts
[01:29:28.078]                           grepl <- base::grepl
[01:29:28.078]                           restarts <- computeRestarts(cond)
[01:29:28.078]                           for (restart in restarts) {
[01:29:28.078]                             name <- restart$name
[01:29:28.078]                             if (is.null(name)) 
[01:29:28.078]                               next
[01:29:28.078]                             if (!grepl(pattern, name)) 
[01:29:28.078]                               next
[01:29:28.078]                             invokeRestart(restart)
[01:29:28.078]                             muffled <- TRUE
[01:29:28.078]                             break
[01:29:28.078]                           }
[01:29:28.078]                         }
[01:29:28.078]                       }
[01:29:28.078]                       invisible(muffled)
[01:29:28.078]                     }
[01:29:28.078]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.078]                   }
[01:29:28.078]                 }
[01:29:28.078]             }
[01:29:28.078]         }))
[01:29:28.078]     }, error = function(ex) {
[01:29:28.078]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.078]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.078]                 ...future.rng), started = ...future.startTime, 
[01:29:28.078]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.078]             version = "1.8"), class = "FutureResult")
[01:29:28.078]     }, finally = {
[01:29:28.078]         if (!identical(...future.workdir, getwd())) 
[01:29:28.078]             setwd(...future.workdir)
[01:29:28.078]         {
[01:29:28.078]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.078]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.078]             }
[01:29:28.078]             base::options(...future.oldOptions)
[01:29:28.078]             if (.Platform$OS.type == "windows") {
[01:29:28.078]                 old_names <- names(...future.oldEnvVars)
[01:29:28.078]                 envs <- base::Sys.getenv()
[01:29:28.078]                 names <- names(envs)
[01:29:28.078]                 common <- intersect(names, old_names)
[01:29:28.078]                 added <- setdiff(names, old_names)
[01:29:28.078]                 removed <- setdiff(old_names, names)
[01:29:28.078]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.078]                   envs[common]]
[01:29:28.078]                 NAMES <- toupper(changed)
[01:29:28.078]                 args <- list()
[01:29:28.078]                 for (kk in seq_along(NAMES)) {
[01:29:28.078]                   name <- changed[[kk]]
[01:29:28.078]                   NAME <- NAMES[[kk]]
[01:29:28.078]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.078]                     next
[01:29:28.078]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.078]                 }
[01:29:28.078]                 NAMES <- toupper(added)
[01:29:28.078]                 for (kk in seq_along(NAMES)) {
[01:29:28.078]                   name <- added[[kk]]
[01:29:28.078]                   NAME <- NAMES[[kk]]
[01:29:28.078]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.078]                     next
[01:29:28.078]                   args[[name]] <- ""
[01:29:28.078]                 }
[01:29:28.078]                 NAMES <- toupper(removed)
[01:29:28.078]                 for (kk in seq_along(NAMES)) {
[01:29:28.078]                   name <- removed[[kk]]
[01:29:28.078]                   NAME <- NAMES[[kk]]
[01:29:28.078]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.078]                     next
[01:29:28.078]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.078]                 }
[01:29:28.078]                 if (length(args) > 0) 
[01:29:28.078]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.078]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.078]             }
[01:29:28.078]             else {
[01:29:28.078]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.078]             }
[01:29:28.078]             {
[01:29:28.078]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.078]                   0L) {
[01:29:28.078]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.078]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.078]                   base::options(opts)
[01:29:28.078]                 }
[01:29:28.078]                 {
[01:29:28.078]                   {
[01:29:28.078]                     base::assign(".Random.seed", c(10407L, -1054261393L, 
[01:29:28.078]                     -1825904242L, 1941203574L, -881861939L, 1224514573L, 
[01:29:28.078]                     -1732441100L), envir = base::globalenv(), 
[01:29:28.078]                       inherits = FALSE)
[01:29:28.078]                     NULL
[01:29:28.078]                   }
[01:29:28.078]                   options(future.plan = NULL)
[01:29:28.078]                   if (is.na(NA_character_)) 
[01:29:28.078]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.078]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.078]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.078]                   {
[01:29:28.078]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.078]                     if (!future$lazy) 
[01:29:28.078]                       future <- run(future)
[01:29:28.078]                     invisible(future)
[01:29:28.078]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.078]                 }
[01:29:28.078]             }
[01:29:28.078]         }
[01:29:28.078]     })
[01:29:28.078]     if (TRUE) {
[01:29:28.078]         base::sink(type = "output", split = FALSE)
[01:29:28.078]         if (TRUE) {
[01:29:28.078]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.078]         }
[01:29:28.078]         else {
[01:29:28.078]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.078]         }
[01:29:28.078]         base::close(...future.stdout)
[01:29:28.078]         ...future.stdout <- NULL
[01:29:28.078]     }
[01:29:28.078]     ...future.result$conditions <- ...future.conditions
[01:29:28.078]     ...future.result$finished <- base::Sys.time()
[01:29:28.078]     ...future.result
[01:29:28.078] }
[01:29:28.082] assign_globals() ...
[01:29:28.082] List of 1
[01:29:28.082]  $ x: int [1:4] 0 1 2 3
[01:29:28.082]  - attr(*, "where")=List of 1
[01:29:28.082]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.082]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.082]  - attr(*, "resolved")= logi FALSE
[01:29:28.082]  - attr(*, "total_size")= num 64
[01:29:28.082]  - attr(*, "already-done")= logi TRUE
[01:29:28.085] - copied 'x' to environment
[01:29:28.086] assign_globals() ... done
[01:29:28.086] plan(): Setting new future strategy stack:
[01:29:28.086] List of future strategies:
[01:29:28.086] 1. sequential:
[01:29:28.086]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.086]    - tweaked: FALSE
[01:29:28.086]    - call: NULL
[01:29:28.087] plan(): nbrOfWorkers() = 1
[01:29:28.088] plan(): Setting new future strategy stack:
[01:29:28.088] List of future strategies:
[01:29:28.088] 1. sequential:
[01:29:28.088]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.088]    - tweaked: FALSE
[01:29:28.088]    - call: plan(strategy)
[01:29:28.089] plan(): nbrOfWorkers() = 1
[01:29:28.089] SequentialFuture started (and completed)
[01:29:28.089] - Launch lazy future ... done
[01:29:28.090] run() for 'SequentialFuture' ... done
[01:29:28.090] getGlobalsAndPackages() ...
[01:29:28.090] Searching for globals...
[01:29:28.092] - globals found: [3] '{', 'sample', 'x'
[01:29:28.092] Searching for globals ... DONE
[01:29:28.092] Resolving globals: FALSE
[01:29:28.093] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.093] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.093] - globals: [1] 'x'
[01:29:28.093] 
[01:29:28.094] getGlobalsAndPackages() ... DONE
[01:29:28.094] run() for 'Future' ...
[01:29:28.094] - state: 'created'
[01:29:28.094] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.095] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.095] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.095]   - Field: 'label'
[01:29:28.095]   - Field: 'local'
[01:29:28.096]   - Field: 'owner'
[01:29:28.096]   - Field: 'envir'
[01:29:28.096]   - Field: 'packages'
[01:29:28.097]   - Field: 'gc'
[01:29:28.097]   - Field: 'conditions'
[01:29:28.097]   - Field: 'expr'
[01:29:28.098]   - Field: 'uuid'
[01:29:28.098]   - Field: 'seed'
[01:29:28.098]   - Field: 'version'
[01:29:28.098]   - Field: 'result'
[01:29:28.098]   - Field: 'asynchronous'
[01:29:28.099]   - Field: 'calls'
[01:29:28.099]   - Field: 'globals'
[01:29:28.099]   - Field: 'stdout'
[01:29:28.099]   - Field: 'earlySignal'
[01:29:28.099]   - Field: 'lazy'
[01:29:28.100]   - Field: 'state'
[01:29:28.100] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.100] - Launch lazy future ...
[01:29:28.100] Packages needed by the future expression (n = 0): <none>
[01:29:28.101] Packages needed by future strategies (n = 0): <none>
[01:29:28.101] {
[01:29:28.101]     {
[01:29:28.101]         {
[01:29:28.101]             ...future.startTime <- base::Sys.time()
[01:29:28.101]             {
[01:29:28.101]                 {
[01:29:28.101]                   {
[01:29:28.101]                     base::local({
[01:29:28.101]                       has_future <- base::requireNamespace("future", 
[01:29:28.101]                         quietly = TRUE)
[01:29:28.101]                       if (has_future) {
[01:29:28.101]                         ns <- base::getNamespace("future")
[01:29:28.101]                         version <- ns[[".package"]][["version"]]
[01:29:28.101]                         if (is.null(version)) 
[01:29:28.101]                           version <- utils::packageVersion("future")
[01:29:28.101]                       }
[01:29:28.101]                       else {
[01:29:28.101]                         version <- NULL
[01:29:28.101]                       }
[01:29:28.101]                       if (!has_future || version < "1.8.0") {
[01:29:28.101]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.101]                           "", base::R.version$version.string), 
[01:29:28.101]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.101]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.101]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.101]                             "release", "version")], collapse = " "), 
[01:29:28.101]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.101]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.101]                           info)
[01:29:28.101]                         info <- base::paste(info, collapse = "; ")
[01:29:28.101]                         if (!has_future) {
[01:29:28.101]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.101]                             info)
[01:29:28.101]                         }
[01:29:28.101]                         else {
[01:29:28.101]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.101]                             info, version)
[01:29:28.101]                         }
[01:29:28.101]                         base::stop(msg)
[01:29:28.101]                       }
[01:29:28.101]                     })
[01:29:28.101]                   }
[01:29:28.101]                   options(future.plan = NULL)
[01:29:28.101]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.101]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.101]                 }
[01:29:28.101]                 ...future.workdir <- getwd()
[01:29:28.101]             }
[01:29:28.101]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.101]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.101]         }
[01:29:28.101]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.101]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.101]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.101]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.101]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.101]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.101]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.101]             base::names(...future.oldOptions))
[01:29:28.101]     }
[01:29:28.101]     if (FALSE) {
[01:29:28.101]     }
[01:29:28.101]     else {
[01:29:28.101]         if (TRUE) {
[01:29:28.101]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.101]                 open = "w")
[01:29:28.101]         }
[01:29:28.101]         else {
[01:29:28.101]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.101]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.101]         }
[01:29:28.101]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.101]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.101]             base::sink(type = "output", split = FALSE)
[01:29:28.101]             base::close(...future.stdout)
[01:29:28.101]         }, add = TRUE)
[01:29:28.101]     }
[01:29:28.101]     ...future.frame <- base::sys.nframe()
[01:29:28.101]     ...future.conditions <- base::list()
[01:29:28.101]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.101]     if (FALSE) {
[01:29:28.101]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.101]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.101]     }
[01:29:28.101]     ...future.result <- base::tryCatch({
[01:29:28.101]         base::withCallingHandlers({
[01:29:28.101]             ...future.value <- base::withVisible(base::local({
[01:29:28.101]                 sample(x, size = 1L)
[01:29:28.101]             }))
[01:29:28.101]             future::FutureResult(value = ...future.value$value, 
[01:29:28.101]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.101]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.101]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.101]                     ...future.globalenv.names))
[01:29:28.101]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.101]         }, condition = base::local({
[01:29:28.101]             c <- base::c
[01:29:28.101]             inherits <- base::inherits
[01:29:28.101]             invokeRestart <- base::invokeRestart
[01:29:28.101]             length <- base::length
[01:29:28.101]             list <- base::list
[01:29:28.101]             seq.int <- base::seq.int
[01:29:28.101]             signalCondition <- base::signalCondition
[01:29:28.101]             sys.calls <- base::sys.calls
[01:29:28.101]             `[[` <- base::`[[`
[01:29:28.101]             `+` <- base::`+`
[01:29:28.101]             `<<-` <- base::`<<-`
[01:29:28.101]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.101]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.101]                   3L)]
[01:29:28.101]             }
[01:29:28.101]             function(cond) {
[01:29:28.101]                 is_error <- inherits(cond, "error")
[01:29:28.101]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.101]                   NULL)
[01:29:28.101]                 if (is_error) {
[01:29:28.101]                   sessionInformation <- function() {
[01:29:28.101]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.101]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.101]                       search = base::search(), system = base::Sys.info())
[01:29:28.101]                   }
[01:29:28.101]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.101]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.101]                     cond$call), session = sessionInformation(), 
[01:29:28.101]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.101]                   signalCondition(cond)
[01:29:28.101]                 }
[01:29:28.101]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.101]                 "immediateCondition"))) {
[01:29:28.101]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.101]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.101]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.101]                   if (TRUE && !signal) {
[01:29:28.101]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.101]                     {
[01:29:28.101]                       inherits <- base::inherits
[01:29:28.101]                       invokeRestart <- base::invokeRestart
[01:29:28.101]                       is.null <- base::is.null
[01:29:28.101]                       muffled <- FALSE
[01:29:28.101]                       if (inherits(cond, "message")) {
[01:29:28.101]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.101]                         if (muffled) 
[01:29:28.101]                           invokeRestart("muffleMessage")
[01:29:28.101]                       }
[01:29:28.101]                       else if (inherits(cond, "warning")) {
[01:29:28.101]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.101]                         if (muffled) 
[01:29:28.101]                           invokeRestart("muffleWarning")
[01:29:28.101]                       }
[01:29:28.101]                       else if (inherits(cond, "condition")) {
[01:29:28.101]                         if (!is.null(pattern)) {
[01:29:28.101]                           computeRestarts <- base::computeRestarts
[01:29:28.101]                           grepl <- base::grepl
[01:29:28.101]                           restarts <- computeRestarts(cond)
[01:29:28.101]                           for (restart in restarts) {
[01:29:28.101]                             name <- restart$name
[01:29:28.101]                             if (is.null(name)) 
[01:29:28.101]                               next
[01:29:28.101]                             if (!grepl(pattern, name)) 
[01:29:28.101]                               next
[01:29:28.101]                             invokeRestart(restart)
[01:29:28.101]                             muffled <- TRUE
[01:29:28.101]                             break
[01:29:28.101]                           }
[01:29:28.101]                         }
[01:29:28.101]                       }
[01:29:28.101]                       invisible(muffled)
[01:29:28.101]                     }
[01:29:28.101]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.101]                   }
[01:29:28.101]                 }
[01:29:28.101]                 else {
[01:29:28.101]                   if (TRUE) {
[01:29:28.101]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.101]                     {
[01:29:28.101]                       inherits <- base::inherits
[01:29:28.101]                       invokeRestart <- base::invokeRestart
[01:29:28.101]                       is.null <- base::is.null
[01:29:28.101]                       muffled <- FALSE
[01:29:28.101]                       if (inherits(cond, "message")) {
[01:29:28.101]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.101]                         if (muffled) 
[01:29:28.101]                           invokeRestart("muffleMessage")
[01:29:28.101]                       }
[01:29:28.101]                       else if (inherits(cond, "warning")) {
[01:29:28.101]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.101]                         if (muffled) 
[01:29:28.101]                           invokeRestart("muffleWarning")
[01:29:28.101]                       }
[01:29:28.101]                       else if (inherits(cond, "condition")) {
[01:29:28.101]                         if (!is.null(pattern)) {
[01:29:28.101]                           computeRestarts <- base::computeRestarts
[01:29:28.101]                           grepl <- base::grepl
[01:29:28.101]                           restarts <- computeRestarts(cond)
[01:29:28.101]                           for (restart in restarts) {
[01:29:28.101]                             name <- restart$name
[01:29:28.101]                             if (is.null(name)) 
[01:29:28.101]                               next
[01:29:28.101]                             if (!grepl(pattern, name)) 
[01:29:28.101]                               next
[01:29:28.101]                             invokeRestart(restart)
[01:29:28.101]                             muffled <- TRUE
[01:29:28.101]                             break
[01:29:28.101]                           }
[01:29:28.101]                         }
[01:29:28.101]                       }
[01:29:28.101]                       invisible(muffled)
[01:29:28.101]                     }
[01:29:28.101]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.101]                   }
[01:29:28.101]                 }
[01:29:28.101]             }
[01:29:28.101]         }))
[01:29:28.101]     }, error = function(ex) {
[01:29:28.101]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.101]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.101]                 ...future.rng), started = ...future.startTime, 
[01:29:28.101]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.101]             version = "1.8"), class = "FutureResult")
[01:29:28.101]     }, finally = {
[01:29:28.101]         if (!identical(...future.workdir, getwd())) 
[01:29:28.101]             setwd(...future.workdir)
[01:29:28.101]         {
[01:29:28.101]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.101]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.101]             }
[01:29:28.101]             base::options(...future.oldOptions)
[01:29:28.101]             if (.Platform$OS.type == "windows") {
[01:29:28.101]                 old_names <- names(...future.oldEnvVars)
[01:29:28.101]                 envs <- base::Sys.getenv()
[01:29:28.101]                 names <- names(envs)
[01:29:28.101]                 common <- intersect(names, old_names)
[01:29:28.101]                 added <- setdiff(names, old_names)
[01:29:28.101]                 removed <- setdiff(old_names, names)
[01:29:28.101]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.101]                   envs[common]]
[01:29:28.101]                 NAMES <- toupper(changed)
[01:29:28.101]                 args <- list()
[01:29:28.101]                 for (kk in seq_along(NAMES)) {
[01:29:28.101]                   name <- changed[[kk]]
[01:29:28.101]                   NAME <- NAMES[[kk]]
[01:29:28.101]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.101]                     next
[01:29:28.101]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.101]                 }
[01:29:28.101]                 NAMES <- toupper(added)
[01:29:28.101]                 for (kk in seq_along(NAMES)) {
[01:29:28.101]                   name <- added[[kk]]
[01:29:28.101]                   NAME <- NAMES[[kk]]
[01:29:28.101]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.101]                     next
[01:29:28.101]                   args[[name]] <- ""
[01:29:28.101]                 }
[01:29:28.101]                 NAMES <- toupper(removed)
[01:29:28.101]                 for (kk in seq_along(NAMES)) {
[01:29:28.101]                   name <- removed[[kk]]
[01:29:28.101]                   NAME <- NAMES[[kk]]
[01:29:28.101]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.101]                     next
[01:29:28.101]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.101]                 }
[01:29:28.101]                 if (length(args) > 0) 
[01:29:28.101]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.101]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.101]             }
[01:29:28.101]             else {
[01:29:28.101]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.101]             }
[01:29:28.101]             {
[01:29:28.101]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.101]                   0L) {
[01:29:28.101]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.101]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.101]                   base::options(opts)
[01:29:28.101]                 }
[01:29:28.101]                 {
[01:29:28.101]                   {
[01:29:28.101]                     base::assign(".Random.seed", c(10407L, 1941203574L, 
[01:29:28.101]                     -680759019L, 1460404464L, -1732441100L, -239407176L, 
[01:29:28.101]                     -1438927716L), envir = base::globalenv(), 
[01:29:28.101]                       inherits = FALSE)
[01:29:28.101]                     NULL
[01:29:28.101]                   }
[01:29:28.101]                   options(future.plan = NULL)
[01:29:28.101]                   if (is.na(NA_character_)) 
[01:29:28.101]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.101]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.101]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.101]                   {
[01:29:28.101]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.101]                     if (!future$lazy) 
[01:29:28.101]                       future <- run(future)
[01:29:28.101]                     invisible(future)
[01:29:28.101]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.101]                 }
[01:29:28.101]             }
[01:29:28.101]         }
[01:29:28.101]     })
[01:29:28.101]     if (TRUE) {
[01:29:28.101]         base::sink(type = "output", split = FALSE)
[01:29:28.101]         if (TRUE) {
[01:29:28.101]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.101]         }
[01:29:28.101]         else {
[01:29:28.101]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.101]         }
[01:29:28.101]         base::close(...future.stdout)
[01:29:28.101]         ...future.stdout <- NULL
[01:29:28.101]     }
[01:29:28.101]     ...future.result$conditions <- ...future.conditions
[01:29:28.101]     ...future.result$finished <- base::Sys.time()
[01:29:28.101]     ...future.result
[01:29:28.101] }
[01:29:28.105] assign_globals() ...
[01:29:28.106] List of 1
[01:29:28.106]  $ x: int [1:4] 0 1 2 3
[01:29:28.106]  - attr(*, "where")=List of 1
[01:29:28.106]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.106]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.106]  - attr(*, "resolved")= logi FALSE
[01:29:28.106]  - attr(*, "total_size")= num 64
[01:29:28.106]  - attr(*, "already-done")= logi TRUE
[01:29:28.112] - copied 'x' to environment
[01:29:28.112] assign_globals() ... done
[01:29:28.112] plan(): Setting new future strategy stack:
[01:29:28.113] List of future strategies:
[01:29:28.113] 1. sequential:
[01:29:28.113]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.113]    - tweaked: FALSE
[01:29:28.113]    - call: NULL
[01:29:28.113] plan(): nbrOfWorkers() = 1
[01:29:28.115] plan(): Setting new future strategy stack:
[01:29:28.115] List of future strategies:
[01:29:28.115] 1. sequential:
[01:29:28.115]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.115]    - tweaked: FALSE
[01:29:28.115]    - call: plan(strategy)
[01:29:28.115] plan(): nbrOfWorkers() = 1
[01:29:28.116] SequentialFuture started (and completed)
[01:29:28.116] - Launch lazy future ... done
[01:29:28.116] run() for 'SequentialFuture' ... done
[[1]]
[1] 0

[[2]]
[1] 2

[[3]]
[1] 1

[[4]]
[1] 3

[01:29:28.118] getGlobalsAndPackages() ...
[01:29:28.118] Searching for globals...
[01:29:28.119] - globals found: [3] '{', 'sample', 'x'
[01:29:28.119] Searching for globals ... DONE
[01:29:28.119] Resolving globals: FALSE
[01:29:28.120] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.120] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.121] - globals: [1] 'x'
[01:29:28.121] 
[01:29:28.121] getGlobalsAndPackages() ... DONE
[01:29:28.121] run() for 'Future' ...
[01:29:28.121] - state: 'created'
[01:29:28.122] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.122] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.122] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.122]   - Field: 'label'
[01:29:28.123]   - Field: 'local'
[01:29:28.123]   - Field: 'owner'
[01:29:28.123]   - Field: 'envir'
[01:29:28.123]   - Field: 'packages'
[01:29:28.123]   - Field: 'gc'
[01:29:28.124]   - Field: 'conditions'
[01:29:28.124]   - Field: 'expr'
[01:29:28.124]   - Field: 'uuid'
[01:29:28.124]   - Field: 'seed'
[01:29:28.124]   - Field: 'version'
[01:29:28.125]   - Field: 'result'
[01:29:28.125]   - Field: 'asynchronous'
[01:29:28.125]   - Field: 'calls'
[01:29:28.125]   - Field: 'globals'
[01:29:28.125]   - Field: 'stdout'
[01:29:28.125]   - Field: 'earlySignal'
[01:29:28.126]   - Field: 'lazy'
[01:29:28.126]   - Field: 'state'
[01:29:28.126] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.126] - Launch lazy future ...
[01:29:28.126] Packages needed by the future expression (n = 0): <none>
[01:29:28.127] Packages needed by future strategies (n = 0): <none>
[01:29:28.127] {
[01:29:28.127]     {
[01:29:28.127]         {
[01:29:28.127]             ...future.startTime <- base::Sys.time()
[01:29:28.127]             {
[01:29:28.127]                 {
[01:29:28.127]                   {
[01:29:28.127]                     base::local({
[01:29:28.127]                       has_future <- base::requireNamespace("future", 
[01:29:28.127]                         quietly = TRUE)
[01:29:28.127]                       if (has_future) {
[01:29:28.127]                         ns <- base::getNamespace("future")
[01:29:28.127]                         version <- ns[[".package"]][["version"]]
[01:29:28.127]                         if (is.null(version)) 
[01:29:28.127]                           version <- utils::packageVersion("future")
[01:29:28.127]                       }
[01:29:28.127]                       else {
[01:29:28.127]                         version <- NULL
[01:29:28.127]                       }
[01:29:28.127]                       if (!has_future || version < "1.8.0") {
[01:29:28.127]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.127]                           "", base::R.version$version.string), 
[01:29:28.127]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.127]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.127]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.127]                             "release", "version")], collapse = " "), 
[01:29:28.127]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.127]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.127]                           info)
[01:29:28.127]                         info <- base::paste(info, collapse = "; ")
[01:29:28.127]                         if (!has_future) {
[01:29:28.127]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.127]                             info)
[01:29:28.127]                         }
[01:29:28.127]                         else {
[01:29:28.127]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.127]                             info, version)
[01:29:28.127]                         }
[01:29:28.127]                         base::stop(msg)
[01:29:28.127]                       }
[01:29:28.127]                     })
[01:29:28.127]                   }
[01:29:28.127]                   options(future.plan = NULL)
[01:29:28.127]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.127]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.127]                 }
[01:29:28.127]                 ...future.workdir <- getwd()
[01:29:28.127]             }
[01:29:28.127]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.127]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.127]         }
[01:29:28.127]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.127]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.127]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.127]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.127]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.127]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.127]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.127]             base::names(...future.oldOptions))
[01:29:28.127]     }
[01:29:28.127]     if (FALSE) {
[01:29:28.127]     }
[01:29:28.127]     else {
[01:29:28.127]         if (TRUE) {
[01:29:28.127]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.127]                 open = "w")
[01:29:28.127]         }
[01:29:28.127]         else {
[01:29:28.127]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.127]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.127]         }
[01:29:28.127]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.127]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.127]             base::sink(type = "output", split = FALSE)
[01:29:28.127]             base::close(...future.stdout)
[01:29:28.127]         }, add = TRUE)
[01:29:28.127]     }
[01:29:28.127]     ...future.frame <- base::sys.nframe()
[01:29:28.127]     ...future.conditions <- base::list()
[01:29:28.127]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.127]     if (FALSE) {
[01:29:28.127]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.127]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.127]     }
[01:29:28.127]     ...future.result <- base::tryCatch({
[01:29:28.127]         base::withCallingHandlers({
[01:29:28.127]             ...future.value <- base::withVisible(base::local({
[01:29:28.127]                 sample(x, size = 1L)
[01:29:28.127]             }))
[01:29:28.127]             future::FutureResult(value = ...future.value$value, 
[01:29:28.127]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.127]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.127]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.127]                     ...future.globalenv.names))
[01:29:28.127]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.127]         }, condition = base::local({
[01:29:28.127]             c <- base::c
[01:29:28.127]             inherits <- base::inherits
[01:29:28.127]             invokeRestart <- base::invokeRestart
[01:29:28.127]             length <- base::length
[01:29:28.127]             list <- base::list
[01:29:28.127]             seq.int <- base::seq.int
[01:29:28.127]             signalCondition <- base::signalCondition
[01:29:28.127]             sys.calls <- base::sys.calls
[01:29:28.127]             `[[` <- base::`[[`
[01:29:28.127]             `+` <- base::`+`
[01:29:28.127]             `<<-` <- base::`<<-`
[01:29:28.127]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.127]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.127]                   3L)]
[01:29:28.127]             }
[01:29:28.127]             function(cond) {
[01:29:28.127]                 is_error <- inherits(cond, "error")
[01:29:28.127]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.127]                   NULL)
[01:29:28.127]                 if (is_error) {
[01:29:28.127]                   sessionInformation <- function() {
[01:29:28.127]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.127]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.127]                       search = base::search(), system = base::Sys.info())
[01:29:28.127]                   }
[01:29:28.127]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.127]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.127]                     cond$call), session = sessionInformation(), 
[01:29:28.127]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.127]                   signalCondition(cond)
[01:29:28.127]                 }
[01:29:28.127]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.127]                 "immediateCondition"))) {
[01:29:28.127]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.127]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.127]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.127]                   if (TRUE && !signal) {
[01:29:28.127]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.127]                     {
[01:29:28.127]                       inherits <- base::inherits
[01:29:28.127]                       invokeRestart <- base::invokeRestart
[01:29:28.127]                       is.null <- base::is.null
[01:29:28.127]                       muffled <- FALSE
[01:29:28.127]                       if (inherits(cond, "message")) {
[01:29:28.127]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.127]                         if (muffled) 
[01:29:28.127]                           invokeRestart("muffleMessage")
[01:29:28.127]                       }
[01:29:28.127]                       else if (inherits(cond, "warning")) {
[01:29:28.127]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.127]                         if (muffled) 
[01:29:28.127]                           invokeRestart("muffleWarning")
[01:29:28.127]                       }
[01:29:28.127]                       else if (inherits(cond, "condition")) {
[01:29:28.127]                         if (!is.null(pattern)) {
[01:29:28.127]                           computeRestarts <- base::computeRestarts
[01:29:28.127]                           grepl <- base::grepl
[01:29:28.127]                           restarts <- computeRestarts(cond)
[01:29:28.127]                           for (restart in restarts) {
[01:29:28.127]                             name <- restart$name
[01:29:28.127]                             if (is.null(name)) 
[01:29:28.127]                               next
[01:29:28.127]                             if (!grepl(pattern, name)) 
[01:29:28.127]                               next
[01:29:28.127]                             invokeRestart(restart)
[01:29:28.127]                             muffled <- TRUE
[01:29:28.127]                             break
[01:29:28.127]                           }
[01:29:28.127]                         }
[01:29:28.127]                       }
[01:29:28.127]                       invisible(muffled)
[01:29:28.127]                     }
[01:29:28.127]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.127]                   }
[01:29:28.127]                 }
[01:29:28.127]                 else {
[01:29:28.127]                   if (TRUE) {
[01:29:28.127]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.127]                     {
[01:29:28.127]                       inherits <- base::inherits
[01:29:28.127]                       invokeRestart <- base::invokeRestart
[01:29:28.127]                       is.null <- base::is.null
[01:29:28.127]                       muffled <- FALSE
[01:29:28.127]                       if (inherits(cond, "message")) {
[01:29:28.127]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.127]                         if (muffled) 
[01:29:28.127]                           invokeRestart("muffleMessage")
[01:29:28.127]                       }
[01:29:28.127]                       else if (inherits(cond, "warning")) {
[01:29:28.127]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.127]                         if (muffled) 
[01:29:28.127]                           invokeRestart("muffleWarning")
[01:29:28.127]                       }
[01:29:28.127]                       else if (inherits(cond, "condition")) {
[01:29:28.127]                         if (!is.null(pattern)) {
[01:29:28.127]                           computeRestarts <- base::computeRestarts
[01:29:28.127]                           grepl <- base::grepl
[01:29:28.127]                           restarts <- computeRestarts(cond)
[01:29:28.127]                           for (restart in restarts) {
[01:29:28.127]                             name <- restart$name
[01:29:28.127]                             if (is.null(name)) 
[01:29:28.127]                               next
[01:29:28.127]                             if (!grepl(pattern, name)) 
[01:29:28.127]                               next
[01:29:28.127]                             invokeRestart(restart)
[01:29:28.127]                             muffled <- TRUE
[01:29:28.127]                             break
[01:29:28.127]                           }
[01:29:28.127]                         }
[01:29:28.127]                       }
[01:29:28.127]                       invisible(muffled)
[01:29:28.127]                     }
[01:29:28.127]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.127]                   }
[01:29:28.127]                 }
[01:29:28.127]             }
[01:29:28.127]         }))
[01:29:28.127]     }, error = function(ex) {
[01:29:28.127]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.127]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.127]                 ...future.rng), started = ...future.startTime, 
[01:29:28.127]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.127]             version = "1.8"), class = "FutureResult")
[01:29:28.127]     }, finally = {
[01:29:28.127]         if (!identical(...future.workdir, getwd())) 
[01:29:28.127]             setwd(...future.workdir)
[01:29:28.127]         {
[01:29:28.127]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.127]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.127]             }
[01:29:28.127]             base::options(...future.oldOptions)
[01:29:28.127]             if (.Platform$OS.type == "windows") {
[01:29:28.127]                 old_names <- names(...future.oldEnvVars)
[01:29:28.127]                 envs <- base::Sys.getenv()
[01:29:28.127]                 names <- names(envs)
[01:29:28.127]                 common <- intersect(names, old_names)
[01:29:28.127]                 added <- setdiff(names, old_names)
[01:29:28.127]                 removed <- setdiff(old_names, names)
[01:29:28.127]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.127]                   envs[common]]
[01:29:28.127]                 NAMES <- toupper(changed)
[01:29:28.127]                 args <- list()
[01:29:28.127]                 for (kk in seq_along(NAMES)) {
[01:29:28.127]                   name <- changed[[kk]]
[01:29:28.127]                   NAME <- NAMES[[kk]]
[01:29:28.127]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.127]                     next
[01:29:28.127]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.127]                 }
[01:29:28.127]                 NAMES <- toupper(added)
[01:29:28.127]                 for (kk in seq_along(NAMES)) {
[01:29:28.127]                   name <- added[[kk]]
[01:29:28.127]                   NAME <- NAMES[[kk]]
[01:29:28.127]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.127]                     next
[01:29:28.127]                   args[[name]] <- ""
[01:29:28.127]                 }
[01:29:28.127]                 NAMES <- toupper(removed)
[01:29:28.127]                 for (kk in seq_along(NAMES)) {
[01:29:28.127]                   name <- removed[[kk]]
[01:29:28.127]                   NAME <- NAMES[[kk]]
[01:29:28.127]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.127]                     next
[01:29:28.127]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.127]                 }
[01:29:28.127]                 if (length(args) > 0) 
[01:29:28.127]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.127]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.127]             }
[01:29:28.127]             else {
[01:29:28.127]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.127]             }
[01:29:28.127]             {
[01:29:28.127]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.127]                   0L) {
[01:29:28.127]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.127]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.127]                   base::options(opts)
[01:29:28.127]                 }
[01:29:28.127]                 {
[01:29:28.127]                   {
[01:29:28.127]                     base::assign(".Random.seed", c(10407L, -1090088410L, 
[01:29:28.127]                     -1005590256L, 316241774L, -589582443L, -318722748L, 
[01:29:28.127]                     -62315152L), envir = base::globalenv(), inherits = FALSE)
[01:29:28.127]                     NULL
[01:29:28.127]                   }
[01:29:28.127]                   options(future.plan = NULL)
[01:29:28.127]                   if (is.na(NA_character_)) 
[01:29:28.127]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.127]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.127]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.127]                   {
[01:29:28.127]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.127]                     if (!future$lazy) 
[01:29:28.127]                       future <- run(future)
[01:29:28.127]                     invisible(future)
[01:29:28.127]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.127]                 }
[01:29:28.127]             }
[01:29:28.127]         }
[01:29:28.127]     })
[01:29:28.127]     if (TRUE) {
[01:29:28.127]         base::sink(type = "output", split = FALSE)
[01:29:28.127]         if (TRUE) {
[01:29:28.127]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.127]         }
[01:29:28.127]         else {
[01:29:28.127]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.127]         }
[01:29:28.127]         base::close(...future.stdout)
[01:29:28.127]         ...future.stdout <- NULL
[01:29:28.127]     }
[01:29:28.127]     ...future.result$conditions <- ...future.conditions
[01:29:28.127]     ...future.result$finished <- base::Sys.time()
[01:29:28.127]     ...future.result
[01:29:28.127] }
[01:29:28.131] assign_globals() ...
[01:29:28.131] List of 1
[01:29:28.131]  $ x: int [1:4] 0 1 2 3
[01:29:28.131]  - attr(*, "where")=List of 1
[01:29:28.131]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.131]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.131]  - attr(*, "resolved")= logi FALSE
[01:29:28.131]  - attr(*, "total_size")= num 64
[01:29:28.131]  - attr(*, "already-done")= logi TRUE
[01:29:28.134] - copied 'x' to environment
[01:29:28.135] assign_globals() ... done
[01:29:28.135] plan(): Setting new future strategy stack:
[01:29:28.135] List of future strategies:
[01:29:28.135] 1. sequential:
[01:29:28.135]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.135]    - tweaked: FALSE
[01:29:28.135]    - call: NULL
[01:29:28.136] plan(): nbrOfWorkers() = 1
[01:29:28.137] plan(): Setting new future strategy stack:
[01:29:28.137] List of future strategies:
[01:29:28.137] 1. sequential:
[01:29:28.137]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.137]    - tweaked: FALSE
[01:29:28.137]    - call: plan(strategy)
[01:29:28.138] plan(): nbrOfWorkers() = 1
[01:29:28.138] SequentialFuture started (and completed)
[01:29:28.138] - Launch lazy future ... done
[01:29:28.138] run() for 'SequentialFuture' ... done
[01:29:28.139] getGlobalsAndPackages() ...
[01:29:28.139] Searching for globals...
[01:29:28.140] - globals found: [3] '{', 'sample', 'x'
[01:29:28.141] Searching for globals ... DONE
[01:29:28.143] Resolving globals: FALSE
[01:29:28.144] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.144] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.144] - globals: [1] 'x'
[01:29:28.145] 
[01:29:28.145] getGlobalsAndPackages() ... DONE
[01:29:28.145] run() for 'Future' ...
[01:29:28.145] - state: 'created'
[01:29:28.146] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.146] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.146] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.146]   - Field: 'label'
[01:29:28.147]   - Field: 'local'
[01:29:28.147]   - Field: 'owner'
[01:29:28.147]   - Field: 'envir'
[01:29:28.147]   - Field: 'packages'
[01:29:28.147]   - Field: 'gc'
[01:29:28.148]   - Field: 'conditions'
[01:29:28.148]   - Field: 'expr'
[01:29:28.148]   - Field: 'uuid'
[01:29:28.148]   - Field: 'seed'
[01:29:28.148]   - Field: 'version'
[01:29:28.148]   - Field: 'result'
[01:29:28.149]   - Field: 'asynchronous'
[01:29:28.149]   - Field: 'calls'
[01:29:28.149]   - Field: 'globals'
[01:29:28.149]   - Field: 'stdout'
[01:29:28.149]   - Field: 'earlySignal'
[01:29:28.150]   - Field: 'lazy'
[01:29:28.150]   - Field: 'state'
[01:29:28.150] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.150] - Launch lazy future ...
[01:29:28.150] Packages needed by the future expression (n = 0): <none>
[01:29:28.151] Packages needed by future strategies (n = 0): <none>
[01:29:28.151] {
[01:29:28.151]     {
[01:29:28.151]         {
[01:29:28.151]             ...future.startTime <- base::Sys.time()
[01:29:28.151]             {
[01:29:28.151]                 {
[01:29:28.151]                   {
[01:29:28.151]                     base::local({
[01:29:28.151]                       has_future <- base::requireNamespace("future", 
[01:29:28.151]                         quietly = TRUE)
[01:29:28.151]                       if (has_future) {
[01:29:28.151]                         ns <- base::getNamespace("future")
[01:29:28.151]                         version <- ns[[".package"]][["version"]]
[01:29:28.151]                         if (is.null(version)) 
[01:29:28.151]                           version <- utils::packageVersion("future")
[01:29:28.151]                       }
[01:29:28.151]                       else {
[01:29:28.151]                         version <- NULL
[01:29:28.151]                       }
[01:29:28.151]                       if (!has_future || version < "1.8.0") {
[01:29:28.151]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.151]                           "", base::R.version$version.string), 
[01:29:28.151]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.151]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.151]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.151]                             "release", "version")], collapse = " "), 
[01:29:28.151]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.151]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.151]                           info)
[01:29:28.151]                         info <- base::paste(info, collapse = "; ")
[01:29:28.151]                         if (!has_future) {
[01:29:28.151]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.151]                             info)
[01:29:28.151]                         }
[01:29:28.151]                         else {
[01:29:28.151]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.151]                             info, version)
[01:29:28.151]                         }
[01:29:28.151]                         base::stop(msg)
[01:29:28.151]                       }
[01:29:28.151]                     })
[01:29:28.151]                   }
[01:29:28.151]                   options(future.plan = NULL)
[01:29:28.151]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.151]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.151]                 }
[01:29:28.151]                 ...future.workdir <- getwd()
[01:29:28.151]             }
[01:29:28.151]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.151]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.151]         }
[01:29:28.151]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.151]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.151]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.151]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.151]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.151]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.151]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.151]             base::names(...future.oldOptions))
[01:29:28.151]     }
[01:29:28.151]     if (FALSE) {
[01:29:28.151]     }
[01:29:28.151]     else {
[01:29:28.151]         if (TRUE) {
[01:29:28.151]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.151]                 open = "w")
[01:29:28.151]         }
[01:29:28.151]         else {
[01:29:28.151]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.151]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.151]         }
[01:29:28.151]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.151]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.151]             base::sink(type = "output", split = FALSE)
[01:29:28.151]             base::close(...future.stdout)
[01:29:28.151]         }, add = TRUE)
[01:29:28.151]     }
[01:29:28.151]     ...future.frame <- base::sys.nframe()
[01:29:28.151]     ...future.conditions <- base::list()
[01:29:28.151]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.151]     if (FALSE) {
[01:29:28.151]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.151]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.151]     }
[01:29:28.151]     ...future.result <- base::tryCatch({
[01:29:28.151]         base::withCallingHandlers({
[01:29:28.151]             ...future.value <- base::withVisible(base::local({
[01:29:28.151]                 sample(x, size = 1L)
[01:29:28.151]             }))
[01:29:28.151]             future::FutureResult(value = ...future.value$value, 
[01:29:28.151]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.151]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.151]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.151]                     ...future.globalenv.names))
[01:29:28.151]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.151]         }, condition = base::local({
[01:29:28.151]             c <- base::c
[01:29:28.151]             inherits <- base::inherits
[01:29:28.151]             invokeRestart <- base::invokeRestart
[01:29:28.151]             length <- base::length
[01:29:28.151]             list <- base::list
[01:29:28.151]             seq.int <- base::seq.int
[01:29:28.151]             signalCondition <- base::signalCondition
[01:29:28.151]             sys.calls <- base::sys.calls
[01:29:28.151]             `[[` <- base::`[[`
[01:29:28.151]             `+` <- base::`+`
[01:29:28.151]             `<<-` <- base::`<<-`
[01:29:28.151]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.151]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.151]                   3L)]
[01:29:28.151]             }
[01:29:28.151]             function(cond) {
[01:29:28.151]                 is_error <- inherits(cond, "error")
[01:29:28.151]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.151]                   NULL)
[01:29:28.151]                 if (is_error) {
[01:29:28.151]                   sessionInformation <- function() {
[01:29:28.151]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.151]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.151]                       search = base::search(), system = base::Sys.info())
[01:29:28.151]                   }
[01:29:28.151]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.151]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.151]                     cond$call), session = sessionInformation(), 
[01:29:28.151]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.151]                   signalCondition(cond)
[01:29:28.151]                 }
[01:29:28.151]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.151]                 "immediateCondition"))) {
[01:29:28.151]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.151]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.151]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.151]                   if (TRUE && !signal) {
[01:29:28.151]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.151]                     {
[01:29:28.151]                       inherits <- base::inherits
[01:29:28.151]                       invokeRestart <- base::invokeRestart
[01:29:28.151]                       is.null <- base::is.null
[01:29:28.151]                       muffled <- FALSE
[01:29:28.151]                       if (inherits(cond, "message")) {
[01:29:28.151]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.151]                         if (muffled) 
[01:29:28.151]                           invokeRestart("muffleMessage")
[01:29:28.151]                       }
[01:29:28.151]                       else if (inherits(cond, "warning")) {
[01:29:28.151]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.151]                         if (muffled) 
[01:29:28.151]                           invokeRestart("muffleWarning")
[01:29:28.151]                       }
[01:29:28.151]                       else if (inherits(cond, "condition")) {
[01:29:28.151]                         if (!is.null(pattern)) {
[01:29:28.151]                           computeRestarts <- base::computeRestarts
[01:29:28.151]                           grepl <- base::grepl
[01:29:28.151]                           restarts <- computeRestarts(cond)
[01:29:28.151]                           for (restart in restarts) {
[01:29:28.151]                             name <- restart$name
[01:29:28.151]                             if (is.null(name)) 
[01:29:28.151]                               next
[01:29:28.151]                             if (!grepl(pattern, name)) 
[01:29:28.151]                               next
[01:29:28.151]                             invokeRestart(restart)
[01:29:28.151]                             muffled <- TRUE
[01:29:28.151]                             break
[01:29:28.151]                           }
[01:29:28.151]                         }
[01:29:28.151]                       }
[01:29:28.151]                       invisible(muffled)
[01:29:28.151]                     }
[01:29:28.151]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.151]                   }
[01:29:28.151]                 }
[01:29:28.151]                 else {
[01:29:28.151]                   if (TRUE) {
[01:29:28.151]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.151]                     {
[01:29:28.151]                       inherits <- base::inherits
[01:29:28.151]                       invokeRestart <- base::invokeRestart
[01:29:28.151]                       is.null <- base::is.null
[01:29:28.151]                       muffled <- FALSE
[01:29:28.151]                       if (inherits(cond, "message")) {
[01:29:28.151]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.151]                         if (muffled) 
[01:29:28.151]                           invokeRestart("muffleMessage")
[01:29:28.151]                       }
[01:29:28.151]                       else if (inherits(cond, "warning")) {
[01:29:28.151]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.151]                         if (muffled) 
[01:29:28.151]                           invokeRestart("muffleWarning")
[01:29:28.151]                       }
[01:29:28.151]                       else if (inherits(cond, "condition")) {
[01:29:28.151]                         if (!is.null(pattern)) {
[01:29:28.151]                           computeRestarts <- base::computeRestarts
[01:29:28.151]                           grepl <- base::grepl
[01:29:28.151]                           restarts <- computeRestarts(cond)
[01:29:28.151]                           for (restart in restarts) {
[01:29:28.151]                             name <- restart$name
[01:29:28.151]                             if (is.null(name)) 
[01:29:28.151]                               next
[01:29:28.151]                             if (!grepl(pattern, name)) 
[01:29:28.151]                               next
[01:29:28.151]                             invokeRestart(restart)
[01:29:28.151]                             muffled <- TRUE
[01:29:28.151]                             break
[01:29:28.151]                           }
[01:29:28.151]                         }
[01:29:28.151]                       }
[01:29:28.151]                       invisible(muffled)
[01:29:28.151]                     }
[01:29:28.151]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.151]                   }
[01:29:28.151]                 }
[01:29:28.151]             }
[01:29:28.151]         }))
[01:29:28.151]     }, error = function(ex) {
[01:29:28.151]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.151]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.151]                 ...future.rng), started = ...future.startTime, 
[01:29:28.151]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.151]             version = "1.8"), class = "FutureResult")
[01:29:28.151]     }, finally = {
[01:29:28.151]         if (!identical(...future.workdir, getwd())) 
[01:29:28.151]             setwd(...future.workdir)
[01:29:28.151]         {
[01:29:28.151]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.151]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.151]             }
[01:29:28.151]             base::options(...future.oldOptions)
[01:29:28.151]             if (.Platform$OS.type == "windows") {
[01:29:28.151]                 old_names <- names(...future.oldEnvVars)
[01:29:28.151]                 envs <- base::Sys.getenv()
[01:29:28.151]                 names <- names(envs)
[01:29:28.151]                 common <- intersect(names, old_names)
[01:29:28.151]                 added <- setdiff(names, old_names)
[01:29:28.151]                 removed <- setdiff(old_names, names)
[01:29:28.151]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.151]                   envs[common]]
[01:29:28.151]                 NAMES <- toupper(changed)
[01:29:28.151]                 args <- list()
[01:29:28.151]                 for (kk in seq_along(NAMES)) {
[01:29:28.151]                   name <- changed[[kk]]
[01:29:28.151]                   NAME <- NAMES[[kk]]
[01:29:28.151]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.151]                     next
[01:29:28.151]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.151]                 }
[01:29:28.151]                 NAMES <- toupper(added)
[01:29:28.151]                 for (kk in seq_along(NAMES)) {
[01:29:28.151]                   name <- added[[kk]]
[01:29:28.151]                   NAME <- NAMES[[kk]]
[01:29:28.151]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.151]                     next
[01:29:28.151]                   args[[name]] <- ""
[01:29:28.151]                 }
[01:29:28.151]                 NAMES <- toupper(removed)
[01:29:28.151]                 for (kk in seq_along(NAMES)) {
[01:29:28.151]                   name <- removed[[kk]]
[01:29:28.151]                   NAME <- NAMES[[kk]]
[01:29:28.151]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.151]                     next
[01:29:28.151]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.151]                 }
[01:29:28.151]                 if (length(args) > 0) 
[01:29:28.151]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.151]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.151]             }
[01:29:28.151]             else {
[01:29:28.151]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.151]             }
[01:29:28.151]             {
[01:29:28.151]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.151]                   0L) {
[01:29:28.151]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.151]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.151]                   base::options(opts)
[01:29:28.151]                 }
[01:29:28.151]                 {
[01:29:28.151]                   {
[01:29:28.151]                     base::assign(".Random.seed", c(10407L, 316241774L, 
[01:29:28.151]                     1425292540L, 905681868L, -62315152L, 381699224L, 
[01:29:28.151]                     1276686987L), envir = base::globalenv(), 
[01:29:28.151]                       inherits = FALSE)
[01:29:28.151]                     NULL
[01:29:28.151]                   }
[01:29:28.151]                   options(future.plan = NULL)
[01:29:28.151]                   if (is.na(NA_character_)) 
[01:29:28.151]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.151]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.151]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.151]                   {
[01:29:28.151]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.151]                     if (!future$lazy) 
[01:29:28.151]                       future <- run(future)
[01:29:28.151]                     invisible(future)
[01:29:28.151]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.151]                 }
[01:29:28.151]             }
[01:29:28.151]         }
[01:29:28.151]     })
[01:29:28.151]     if (TRUE) {
[01:29:28.151]         base::sink(type = "output", split = FALSE)
[01:29:28.151]         if (TRUE) {
[01:29:28.151]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.151]         }
[01:29:28.151]         else {
[01:29:28.151]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.151]         }
[01:29:28.151]         base::close(...future.stdout)
[01:29:28.151]         ...future.stdout <- NULL
[01:29:28.151]     }
[01:29:28.151]     ...future.result$conditions <- ...future.conditions
[01:29:28.151]     ...future.result$finished <- base::Sys.time()
[01:29:28.151]     ...future.result
[01:29:28.151] }
[01:29:28.155] assign_globals() ...
[01:29:28.155] List of 1
[01:29:28.155]  $ x: int [1:4] 0 1 2 3
[01:29:28.155]  - attr(*, "where")=List of 1
[01:29:28.155]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.155]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.155]  - attr(*, "resolved")= logi FALSE
[01:29:28.155]  - attr(*, "total_size")= num 64
[01:29:28.155]  - attr(*, "already-done")= logi TRUE
[01:29:28.159] - copied 'x' to environment
[01:29:28.159] assign_globals() ... done
[01:29:28.160] plan(): Setting new future strategy stack:
[01:29:28.160] List of future strategies:
[01:29:28.160] 1. sequential:
[01:29:28.160]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.160]    - tweaked: FALSE
[01:29:28.160]    - call: NULL
[01:29:28.160] plan(): nbrOfWorkers() = 1
[01:29:28.162] plan(): Setting new future strategy stack:
[01:29:28.162] List of future strategies:
[01:29:28.162] 1. sequential:
[01:29:28.162]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.162]    - tweaked: FALSE
[01:29:28.162]    - call: plan(strategy)
[01:29:28.163] plan(): nbrOfWorkers() = 1
[01:29:28.163] SequentialFuture started (and completed)
[01:29:28.163] - Launch lazy future ... done
[01:29:28.163] run() for 'SequentialFuture' ... done
[01:29:28.164] getGlobalsAndPackages() ...
[01:29:28.164] Searching for globals...
[01:29:28.165] - globals found: [3] '{', 'sample', 'x'
[01:29:28.166] Searching for globals ... DONE
[01:29:28.166] Resolving globals: FALSE
[01:29:28.166] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.167] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.167] - globals: [1] 'x'
[01:29:28.167] 
[01:29:28.168] getGlobalsAndPackages() ... DONE
[01:29:28.168] run() for 'Future' ...
[01:29:28.168] - state: 'created'
[01:29:28.168] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.169] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.169] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.169]   - Field: 'label'
[01:29:28.169]   - Field: 'local'
[01:29:28.170]   - Field: 'owner'
[01:29:28.170]   - Field: 'envir'
[01:29:28.170]   - Field: 'packages'
[01:29:28.170]   - Field: 'gc'
[01:29:28.170]   - Field: 'conditions'
[01:29:28.171]   - Field: 'expr'
[01:29:28.171]   - Field: 'uuid'
[01:29:28.171]   - Field: 'seed'
[01:29:28.171]   - Field: 'version'
[01:29:28.171]   - Field: 'result'
[01:29:28.171]   - Field: 'asynchronous'
[01:29:28.172]   - Field: 'calls'
[01:29:28.172]   - Field: 'globals'
[01:29:28.172]   - Field: 'stdout'
[01:29:28.172]   - Field: 'earlySignal'
[01:29:28.172]   - Field: 'lazy'
[01:29:28.173]   - Field: 'state'
[01:29:28.173] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.173] - Launch lazy future ...
[01:29:28.173] Packages needed by the future expression (n = 0): <none>
[01:29:28.174] Packages needed by future strategies (n = 0): <none>
[01:29:28.174] {
[01:29:28.174]     {
[01:29:28.174]         {
[01:29:28.174]             ...future.startTime <- base::Sys.time()
[01:29:28.174]             {
[01:29:28.174]                 {
[01:29:28.174]                   {
[01:29:28.174]                     base::local({
[01:29:28.174]                       has_future <- base::requireNamespace("future", 
[01:29:28.174]                         quietly = TRUE)
[01:29:28.174]                       if (has_future) {
[01:29:28.174]                         ns <- base::getNamespace("future")
[01:29:28.174]                         version <- ns[[".package"]][["version"]]
[01:29:28.174]                         if (is.null(version)) 
[01:29:28.174]                           version <- utils::packageVersion("future")
[01:29:28.174]                       }
[01:29:28.174]                       else {
[01:29:28.174]                         version <- NULL
[01:29:28.174]                       }
[01:29:28.174]                       if (!has_future || version < "1.8.0") {
[01:29:28.174]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.174]                           "", base::R.version$version.string), 
[01:29:28.174]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.174]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.174]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.174]                             "release", "version")], collapse = " "), 
[01:29:28.174]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.174]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.174]                           info)
[01:29:28.174]                         info <- base::paste(info, collapse = "; ")
[01:29:28.174]                         if (!has_future) {
[01:29:28.174]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.174]                             info)
[01:29:28.174]                         }
[01:29:28.174]                         else {
[01:29:28.174]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.174]                             info, version)
[01:29:28.174]                         }
[01:29:28.174]                         base::stop(msg)
[01:29:28.174]                       }
[01:29:28.174]                     })
[01:29:28.174]                   }
[01:29:28.174]                   options(future.plan = NULL)
[01:29:28.174]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.174]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.174]                 }
[01:29:28.174]                 ...future.workdir <- getwd()
[01:29:28.174]             }
[01:29:28.174]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.174]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.174]         }
[01:29:28.174]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.174]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.174]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.174]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.174]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.174]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.174]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.174]             base::names(...future.oldOptions))
[01:29:28.174]     }
[01:29:28.174]     if (FALSE) {
[01:29:28.174]     }
[01:29:28.174]     else {
[01:29:28.174]         if (TRUE) {
[01:29:28.174]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.174]                 open = "w")
[01:29:28.174]         }
[01:29:28.174]         else {
[01:29:28.174]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.174]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.174]         }
[01:29:28.174]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.174]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.174]             base::sink(type = "output", split = FALSE)
[01:29:28.174]             base::close(...future.stdout)
[01:29:28.174]         }, add = TRUE)
[01:29:28.174]     }
[01:29:28.174]     ...future.frame <- base::sys.nframe()
[01:29:28.174]     ...future.conditions <- base::list()
[01:29:28.174]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.174]     if (FALSE) {
[01:29:28.174]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.174]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.174]     }
[01:29:28.174]     ...future.result <- base::tryCatch({
[01:29:28.174]         base::withCallingHandlers({
[01:29:28.174]             ...future.value <- base::withVisible(base::local({
[01:29:28.174]                 sample(x, size = 1L)
[01:29:28.174]             }))
[01:29:28.174]             future::FutureResult(value = ...future.value$value, 
[01:29:28.174]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.174]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.174]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.174]                     ...future.globalenv.names))
[01:29:28.174]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.174]         }, condition = base::local({
[01:29:28.174]             c <- base::c
[01:29:28.174]             inherits <- base::inherits
[01:29:28.174]             invokeRestart <- base::invokeRestart
[01:29:28.174]             length <- base::length
[01:29:28.174]             list <- base::list
[01:29:28.174]             seq.int <- base::seq.int
[01:29:28.174]             signalCondition <- base::signalCondition
[01:29:28.174]             sys.calls <- base::sys.calls
[01:29:28.174]             `[[` <- base::`[[`
[01:29:28.174]             `+` <- base::`+`
[01:29:28.174]             `<<-` <- base::`<<-`
[01:29:28.174]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.174]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.174]                   3L)]
[01:29:28.174]             }
[01:29:28.174]             function(cond) {
[01:29:28.174]                 is_error <- inherits(cond, "error")
[01:29:28.174]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.174]                   NULL)
[01:29:28.174]                 if (is_error) {
[01:29:28.174]                   sessionInformation <- function() {
[01:29:28.174]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.174]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.174]                       search = base::search(), system = base::Sys.info())
[01:29:28.174]                   }
[01:29:28.174]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.174]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.174]                     cond$call), session = sessionInformation(), 
[01:29:28.174]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.174]                   signalCondition(cond)
[01:29:28.174]                 }
[01:29:28.174]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.174]                 "immediateCondition"))) {
[01:29:28.174]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.174]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.174]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.174]                   if (TRUE && !signal) {
[01:29:28.174]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.174]                     {
[01:29:28.174]                       inherits <- base::inherits
[01:29:28.174]                       invokeRestart <- base::invokeRestart
[01:29:28.174]                       is.null <- base::is.null
[01:29:28.174]                       muffled <- FALSE
[01:29:28.174]                       if (inherits(cond, "message")) {
[01:29:28.174]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.174]                         if (muffled) 
[01:29:28.174]                           invokeRestart("muffleMessage")
[01:29:28.174]                       }
[01:29:28.174]                       else if (inherits(cond, "warning")) {
[01:29:28.174]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.174]                         if (muffled) 
[01:29:28.174]                           invokeRestart("muffleWarning")
[01:29:28.174]                       }
[01:29:28.174]                       else if (inherits(cond, "condition")) {
[01:29:28.174]                         if (!is.null(pattern)) {
[01:29:28.174]                           computeRestarts <- base::computeRestarts
[01:29:28.174]                           grepl <- base::grepl
[01:29:28.174]                           restarts <- computeRestarts(cond)
[01:29:28.174]                           for (restart in restarts) {
[01:29:28.174]                             name <- restart$name
[01:29:28.174]                             if (is.null(name)) 
[01:29:28.174]                               next
[01:29:28.174]                             if (!grepl(pattern, name)) 
[01:29:28.174]                               next
[01:29:28.174]                             invokeRestart(restart)
[01:29:28.174]                             muffled <- TRUE
[01:29:28.174]                             break
[01:29:28.174]                           }
[01:29:28.174]                         }
[01:29:28.174]                       }
[01:29:28.174]                       invisible(muffled)
[01:29:28.174]                     }
[01:29:28.174]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.174]                   }
[01:29:28.174]                 }
[01:29:28.174]                 else {
[01:29:28.174]                   if (TRUE) {
[01:29:28.174]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.174]                     {
[01:29:28.174]                       inherits <- base::inherits
[01:29:28.174]                       invokeRestart <- base::invokeRestart
[01:29:28.174]                       is.null <- base::is.null
[01:29:28.174]                       muffled <- FALSE
[01:29:28.174]                       if (inherits(cond, "message")) {
[01:29:28.174]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.174]                         if (muffled) 
[01:29:28.174]                           invokeRestart("muffleMessage")
[01:29:28.174]                       }
[01:29:28.174]                       else if (inherits(cond, "warning")) {
[01:29:28.174]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.174]                         if (muffled) 
[01:29:28.174]                           invokeRestart("muffleWarning")
[01:29:28.174]                       }
[01:29:28.174]                       else if (inherits(cond, "condition")) {
[01:29:28.174]                         if (!is.null(pattern)) {
[01:29:28.174]                           computeRestarts <- base::computeRestarts
[01:29:28.174]                           grepl <- base::grepl
[01:29:28.174]                           restarts <- computeRestarts(cond)
[01:29:28.174]                           for (restart in restarts) {
[01:29:28.174]                             name <- restart$name
[01:29:28.174]                             if (is.null(name)) 
[01:29:28.174]                               next
[01:29:28.174]                             if (!grepl(pattern, name)) 
[01:29:28.174]                               next
[01:29:28.174]                             invokeRestart(restart)
[01:29:28.174]                             muffled <- TRUE
[01:29:28.174]                             break
[01:29:28.174]                           }
[01:29:28.174]                         }
[01:29:28.174]                       }
[01:29:28.174]                       invisible(muffled)
[01:29:28.174]                     }
[01:29:28.174]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.174]                   }
[01:29:28.174]                 }
[01:29:28.174]             }
[01:29:28.174]         }))
[01:29:28.174]     }, error = function(ex) {
[01:29:28.174]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.174]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.174]                 ...future.rng), started = ...future.startTime, 
[01:29:28.174]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.174]             version = "1.8"), class = "FutureResult")
[01:29:28.174]     }, finally = {
[01:29:28.174]         if (!identical(...future.workdir, getwd())) 
[01:29:28.174]             setwd(...future.workdir)
[01:29:28.174]         {
[01:29:28.174]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.174]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.174]             }
[01:29:28.174]             base::options(...future.oldOptions)
[01:29:28.174]             if (.Platform$OS.type == "windows") {
[01:29:28.174]                 old_names <- names(...future.oldEnvVars)
[01:29:28.174]                 envs <- base::Sys.getenv()
[01:29:28.174]                 names <- names(envs)
[01:29:28.174]                 common <- intersect(names, old_names)
[01:29:28.174]                 added <- setdiff(names, old_names)
[01:29:28.174]                 removed <- setdiff(old_names, names)
[01:29:28.174]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.174]                   envs[common]]
[01:29:28.174]                 NAMES <- toupper(changed)
[01:29:28.174]                 args <- list()
[01:29:28.174]                 for (kk in seq_along(NAMES)) {
[01:29:28.174]                   name <- changed[[kk]]
[01:29:28.174]                   NAME <- NAMES[[kk]]
[01:29:28.174]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.174]                     next
[01:29:28.174]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.174]                 }
[01:29:28.174]                 NAMES <- toupper(added)
[01:29:28.174]                 for (kk in seq_along(NAMES)) {
[01:29:28.174]                   name <- added[[kk]]
[01:29:28.174]                   NAME <- NAMES[[kk]]
[01:29:28.174]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.174]                     next
[01:29:28.174]                   args[[name]] <- ""
[01:29:28.174]                 }
[01:29:28.174]                 NAMES <- toupper(removed)
[01:29:28.174]                 for (kk in seq_along(NAMES)) {
[01:29:28.174]                   name <- removed[[kk]]
[01:29:28.174]                   NAME <- NAMES[[kk]]
[01:29:28.174]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.174]                     next
[01:29:28.174]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.174]                 }
[01:29:28.174]                 if (length(args) > 0) 
[01:29:28.174]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.174]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.174]             }
[01:29:28.174]             else {
[01:29:28.174]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.174]             }
[01:29:28.174]             {
[01:29:28.174]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.174]                   0L) {
[01:29:28.174]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.174]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.174]                   base::options(opts)
[01:29:28.174]                 }
[01:29:28.174]                 {
[01:29:28.174]                   {
[01:29:28.174]                     base::assign(".Random.seed", c(10407L, 332331236L, 
[01:29:28.174]                     -1265839190L, -138661437L, -1350006441L, 
[01:29:28.174]                     515236994L, 647840892L), envir = base::globalenv(), 
[01:29:28.174]                       inherits = FALSE)
[01:29:28.174]                     NULL
[01:29:28.174]                   }
[01:29:28.174]                   options(future.plan = NULL)
[01:29:28.174]                   if (is.na(NA_character_)) 
[01:29:28.174]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.174]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.174]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.174]                   {
[01:29:28.174]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.174]                     if (!future$lazy) 
[01:29:28.174]                       future <- run(future)
[01:29:28.174]                     invisible(future)
[01:29:28.174]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.174]                 }
[01:29:28.174]             }
[01:29:28.174]         }
[01:29:28.174]     })
[01:29:28.174]     if (TRUE) {
[01:29:28.174]         base::sink(type = "output", split = FALSE)
[01:29:28.174]         if (TRUE) {
[01:29:28.174]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.174]         }
[01:29:28.174]         else {
[01:29:28.174]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.174]         }
[01:29:28.174]         base::close(...future.stdout)
[01:29:28.174]         ...future.stdout <- NULL
[01:29:28.174]     }
[01:29:28.174]     ...future.result$conditions <- ...future.conditions
[01:29:28.174]     ...future.result$finished <- base::Sys.time()
[01:29:28.174]     ...future.result
[01:29:28.174] }
[01:29:28.178] assign_globals() ...
[01:29:28.184] List of 1
[01:29:28.184]  $ x: int [1:4] 0 1 2 3
[01:29:28.184]  - attr(*, "where")=List of 1
[01:29:28.184]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.184]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.184]  - attr(*, "resolved")= logi FALSE
[01:29:28.184]  - attr(*, "total_size")= num 64
[01:29:28.184]  - attr(*, "already-done")= logi TRUE
[01:29:28.187] - copied 'x' to environment
[01:29:28.187] assign_globals() ... done
[01:29:28.188] plan(): Setting new future strategy stack:
[01:29:28.188] List of future strategies:
[01:29:28.188] 1. sequential:
[01:29:28.188]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.188]    - tweaked: FALSE
[01:29:28.188]    - call: NULL
[01:29:28.189] plan(): nbrOfWorkers() = 1
[01:29:28.190] plan(): Setting new future strategy stack:
[01:29:28.190] List of future strategies:
[01:29:28.190] 1. sequential:
[01:29:28.190]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.190]    - tweaked: FALSE
[01:29:28.190]    - call: plan(strategy)
[01:29:28.191] plan(): nbrOfWorkers() = 1
[01:29:28.191] SequentialFuture started (and completed)
[01:29:28.191] - Launch lazy future ... done
[01:29:28.192] run() for 'SequentialFuture' ... done
[01:29:28.192] getGlobalsAndPackages() ...
[01:29:28.192] Searching for globals...
[01:29:28.194] - globals found: [3] '{', 'sample', 'x'
[01:29:28.194] Searching for globals ... DONE
[01:29:28.194] Resolving globals: FALSE
[01:29:28.195] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.195] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.195] - globals: [1] 'x'
[01:29:28.195] 
[01:29:28.196] getGlobalsAndPackages() ... DONE
[01:29:28.196] run() for 'Future' ...
[01:29:28.196] - state: 'created'
[01:29:28.196] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.197] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.197] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.197]   - Field: 'label'
[01:29:28.197]   - Field: 'local'
[01:29:28.198]   - Field: 'owner'
[01:29:28.198]   - Field: 'envir'
[01:29:28.198]   - Field: 'packages'
[01:29:28.198]   - Field: 'gc'
[01:29:28.198]   - Field: 'conditions'
[01:29:28.198]   - Field: 'expr'
[01:29:28.199]   - Field: 'uuid'
[01:29:28.199]   - Field: 'seed'
[01:29:28.199]   - Field: 'version'
[01:29:28.199]   - Field: 'result'
[01:29:28.199]   - Field: 'asynchronous'
[01:29:28.200]   - Field: 'calls'
[01:29:28.200]   - Field: 'globals'
[01:29:28.200]   - Field: 'stdout'
[01:29:28.200]   - Field: 'earlySignal'
[01:29:28.200]   - Field: 'lazy'
[01:29:28.201]   - Field: 'state'
[01:29:28.201] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.201] - Launch lazy future ...
[01:29:28.201] Packages needed by the future expression (n = 0): <none>
[01:29:28.201] Packages needed by future strategies (n = 0): <none>
[01:29:28.202] {
[01:29:28.202]     {
[01:29:28.202]         {
[01:29:28.202]             ...future.startTime <- base::Sys.time()
[01:29:28.202]             {
[01:29:28.202]                 {
[01:29:28.202]                   {
[01:29:28.202]                     base::local({
[01:29:28.202]                       has_future <- base::requireNamespace("future", 
[01:29:28.202]                         quietly = TRUE)
[01:29:28.202]                       if (has_future) {
[01:29:28.202]                         ns <- base::getNamespace("future")
[01:29:28.202]                         version <- ns[[".package"]][["version"]]
[01:29:28.202]                         if (is.null(version)) 
[01:29:28.202]                           version <- utils::packageVersion("future")
[01:29:28.202]                       }
[01:29:28.202]                       else {
[01:29:28.202]                         version <- NULL
[01:29:28.202]                       }
[01:29:28.202]                       if (!has_future || version < "1.8.0") {
[01:29:28.202]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.202]                           "", base::R.version$version.string), 
[01:29:28.202]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.202]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.202]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.202]                             "release", "version")], collapse = " "), 
[01:29:28.202]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.202]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.202]                           info)
[01:29:28.202]                         info <- base::paste(info, collapse = "; ")
[01:29:28.202]                         if (!has_future) {
[01:29:28.202]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.202]                             info)
[01:29:28.202]                         }
[01:29:28.202]                         else {
[01:29:28.202]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.202]                             info, version)
[01:29:28.202]                         }
[01:29:28.202]                         base::stop(msg)
[01:29:28.202]                       }
[01:29:28.202]                     })
[01:29:28.202]                   }
[01:29:28.202]                   options(future.plan = NULL)
[01:29:28.202]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.202]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.202]                 }
[01:29:28.202]                 ...future.workdir <- getwd()
[01:29:28.202]             }
[01:29:28.202]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.202]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.202]         }
[01:29:28.202]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.202]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.202]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.202]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.202]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.202]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.202]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.202]             base::names(...future.oldOptions))
[01:29:28.202]     }
[01:29:28.202]     if (FALSE) {
[01:29:28.202]     }
[01:29:28.202]     else {
[01:29:28.202]         if (TRUE) {
[01:29:28.202]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.202]                 open = "w")
[01:29:28.202]         }
[01:29:28.202]         else {
[01:29:28.202]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.202]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.202]         }
[01:29:28.202]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.202]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.202]             base::sink(type = "output", split = FALSE)
[01:29:28.202]             base::close(...future.stdout)
[01:29:28.202]         }, add = TRUE)
[01:29:28.202]     }
[01:29:28.202]     ...future.frame <- base::sys.nframe()
[01:29:28.202]     ...future.conditions <- base::list()
[01:29:28.202]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.202]     if (FALSE) {
[01:29:28.202]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.202]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.202]     }
[01:29:28.202]     ...future.result <- base::tryCatch({
[01:29:28.202]         base::withCallingHandlers({
[01:29:28.202]             ...future.value <- base::withVisible(base::local({
[01:29:28.202]                 sample(x, size = 1L)
[01:29:28.202]             }))
[01:29:28.202]             future::FutureResult(value = ...future.value$value, 
[01:29:28.202]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.202]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.202]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.202]                     ...future.globalenv.names))
[01:29:28.202]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.202]         }, condition = base::local({
[01:29:28.202]             c <- base::c
[01:29:28.202]             inherits <- base::inherits
[01:29:28.202]             invokeRestart <- base::invokeRestart
[01:29:28.202]             length <- base::length
[01:29:28.202]             list <- base::list
[01:29:28.202]             seq.int <- base::seq.int
[01:29:28.202]             signalCondition <- base::signalCondition
[01:29:28.202]             sys.calls <- base::sys.calls
[01:29:28.202]             `[[` <- base::`[[`
[01:29:28.202]             `+` <- base::`+`
[01:29:28.202]             `<<-` <- base::`<<-`
[01:29:28.202]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.202]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.202]                   3L)]
[01:29:28.202]             }
[01:29:28.202]             function(cond) {
[01:29:28.202]                 is_error <- inherits(cond, "error")
[01:29:28.202]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.202]                   NULL)
[01:29:28.202]                 if (is_error) {
[01:29:28.202]                   sessionInformation <- function() {
[01:29:28.202]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.202]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.202]                       search = base::search(), system = base::Sys.info())
[01:29:28.202]                   }
[01:29:28.202]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.202]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.202]                     cond$call), session = sessionInformation(), 
[01:29:28.202]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.202]                   signalCondition(cond)
[01:29:28.202]                 }
[01:29:28.202]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.202]                 "immediateCondition"))) {
[01:29:28.202]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.202]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.202]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.202]                   if (TRUE && !signal) {
[01:29:28.202]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.202]                     {
[01:29:28.202]                       inherits <- base::inherits
[01:29:28.202]                       invokeRestart <- base::invokeRestart
[01:29:28.202]                       is.null <- base::is.null
[01:29:28.202]                       muffled <- FALSE
[01:29:28.202]                       if (inherits(cond, "message")) {
[01:29:28.202]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.202]                         if (muffled) 
[01:29:28.202]                           invokeRestart("muffleMessage")
[01:29:28.202]                       }
[01:29:28.202]                       else if (inherits(cond, "warning")) {
[01:29:28.202]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.202]                         if (muffled) 
[01:29:28.202]                           invokeRestart("muffleWarning")
[01:29:28.202]                       }
[01:29:28.202]                       else if (inherits(cond, "condition")) {
[01:29:28.202]                         if (!is.null(pattern)) {
[01:29:28.202]                           computeRestarts <- base::computeRestarts
[01:29:28.202]                           grepl <- base::grepl
[01:29:28.202]                           restarts <- computeRestarts(cond)
[01:29:28.202]                           for (restart in restarts) {
[01:29:28.202]                             name <- restart$name
[01:29:28.202]                             if (is.null(name)) 
[01:29:28.202]                               next
[01:29:28.202]                             if (!grepl(pattern, name)) 
[01:29:28.202]                               next
[01:29:28.202]                             invokeRestart(restart)
[01:29:28.202]                             muffled <- TRUE
[01:29:28.202]                             break
[01:29:28.202]                           }
[01:29:28.202]                         }
[01:29:28.202]                       }
[01:29:28.202]                       invisible(muffled)
[01:29:28.202]                     }
[01:29:28.202]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.202]                   }
[01:29:28.202]                 }
[01:29:28.202]                 else {
[01:29:28.202]                   if (TRUE) {
[01:29:28.202]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.202]                     {
[01:29:28.202]                       inherits <- base::inherits
[01:29:28.202]                       invokeRestart <- base::invokeRestart
[01:29:28.202]                       is.null <- base::is.null
[01:29:28.202]                       muffled <- FALSE
[01:29:28.202]                       if (inherits(cond, "message")) {
[01:29:28.202]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.202]                         if (muffled) 
[01:29:28.202]                           invokeRestart("muffleMessage")
[01:29:28.202]                       }
[01:29:28.202]                       else if (inherits(cond, "warning")) {
[01:29:28.202]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.202]                         if (muffled) 
[01:29:28.202]                           invokeRestart("muffleWarning")
[01:29:28.202]                       }
[01:29:28.202]                       else if (inherits(cond, "condition")) {
[01:29:28.202]                         if (!is.null(pattern)) {
[01:29:28.202]                           computeRestarts <- base::computeRestarts
[01:29:28.202]                           grepl <- base::grepl
[01:29:28.202]                           restarts <- computeRestarts(cond)
[01:29:28.202]                           for (restart in restarts) {
[01:29:28.202]                             name <- restart$name
[01:29:28.202]                             if (is.null(name)) 
[01:29:28.202]                               next
[01:29:28.202]                             if (!grepl(pattern, name)) 
[01:29:28.202]                               next
[01:29:28.202]                             invokeRestart(restart)
[01:29:28.202]                             muffled <- TRUE
[01:29:28.202]                             break
[01:29:28.202]                           }
[01:29:28.202]                         }
[01:29:28.202]                       }
[01:29:28.202]                       invisible(muffled)
[01:29:28.202]                     }
[01:29:28.202]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.202]                   }
[01:29:28.202]                 }
[01:29:28.202]             }
[01:29:28.202]         }))
[01:29:28.202]     }, error = function(ex) {
[01:29:28.202]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.202]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.202]                 ...future.rng), started = ...future.startTime, 
[01:29:28.202]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.202]             version = "1.8"), class = "FutureResult")
[01:29:28.202]     }, finally = {
[01:29:28.202]         if (!identical(...future.workdir, getwd())) 
[01:29:28.202]             setwd(...future.workdir)
[01:29:28.202]         {
[01:29:28.202]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.202]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.202]             }
[01:29:28.202]             base::options(...future.oldOptions)
[01:29:28.202]             if (.Platform$OS.type == "windows") {
[01:29:28.202]                 old_names <- names(...future.oldEnvVars)
[01:29:28.202]                 envs <- base::Sys.getenv()
[01:29:28.202]                 names <- names(envs)
[01:29:28.202]                 common <- intersect(names, old_names)
[01:29:28.202]                 added <- setdiff(names, old_names)
[01:29:28.202]                 removed <- setdiff(old_names, names)
[01:29:28.202]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.202]                   envs[common]]
[01:29:28.202]                 NAMES <- toupper(changed)
[01:29:28.202]                 args <- list()
[01:29:28.202]                 for (kk in seq_along(NAMES)) {
[01:29:28.202]                   name <- changed[[kk]]
[01:29:28.202]                   NAME <- NAMES[[kk]]
[01:29:28.202]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.202]                     next
[01:29:28.202]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.202]                 }
[01:29:28.202]                 NAMES <- toupper(added)
[01:29:28.202]                 for (kk in seq_along(NAMES)) {
[01:29:28.202]                   name <- added[[kk]]
[01:29:28.202]                   NAME <- NAMES[[kk]]
[01:29:28.202]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.202]                     next
[01:29:28.202]                   args[[name]] <- ""
[01:29:28.202]                 }
[01:29:28.202]                 NAMES <- toupper(removed)
[01:29:28.202]                 for (kk in seq_along(NAMES)) {
[01:29:28.202]                   name <- removed[[kk]]
[01:29:28.202]                   NAME <- NAMES[[kk]]
[01:29:28.202]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.202]                     next
[01:29:28.202]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.202]                 }
[01:29:28.202]                 if (length(args) > 0) 
[01:29:28.202]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.202]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.202]             }
[01:29:28.202]             else {
[01:29:28.202]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.202]             }
[01:29:28.202]             {
[01:29:28.202]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.202]                   0L) {
[01:29:28.202]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.202]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.202]                   base::options(opts)
[01:29:28.202]                 }
[01:29:28.202]                 {
[01:29:28.202]                   {
[01:29:28.202]                     base::assign(".Random.seed", c(10407L, -138661437L, 
[01:29:28.202]                     -1310103936L, -1203097004L, 647840892L, 1770118238L, 
[01:29:28.202]                     858550343L), envir = base::globalenv(), inherits = FALSE)
[01:29:28.202]                     NULL
[01:29:28.202]                   }
[01:29:28.202]                   options(future.plan = NULL)
[01:29:28.202]                   if (is.na(NA_character_)) 
[01:29:28.202]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.202]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.202]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.202]                   {
[01:29:28.202]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.202]                     if (!future$lazy) 
[01:29:28.202]                       future <- run(future)
[01:29:28.202]                     invisible(future)
[01:29:28.202]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.202]                 }
[01:29:28.202]             }
[01:29:28.202]         }
[01:29:28.202]     })
[01:29:28.202]     if (TRUE) {
[01:29:28.202]         base::sink(type = "output", split = FALSE)
[01:29:28.202]         if (TRUE) {
[01:29:28.202]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.202]         }
[01:29:28.202]         else {
[01:29:28.202]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.202]         }
[01:29:28.202]         base::close(...future.stdout)
[01:29:28.202]         ...future.stdout <- NULL
[01:29:28.202]     }
[01:29:28.202]     ...future.result$conditions <- ...future.conditions
[01:29:28.202]     ...future.result$finished <- base::Sys.time()
[01:29:28.202]     ...future.result
[01:29:28.202] }
[01:29:28.206] assign_globals() ...
[01:29:28.206] List of 1
[01:29:28.206]  $ x: int [1:4] 0 1 2 3
[01:29:28.206]  - attr(*, "where")=List of 1
[01:29:28.206]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.206]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.206]  - attr(*, "resolved")= logi FALSE
[01:29:28.206]  - attr(*, "total_size")= num 64
[01:29:28.206]  - attr(*, "already-done")= logi TRUE
[01:29:28.209] - copied 'x' to environment
[01:29:28.209] assign_globals() ... done
[01:29:28.210] plan(): Setting new future strategy stack:
[01:29:28.210] List of future strategies:
[01:29:28.210] 1. sequential:
[01:29:28.210]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.210]    - tweaked: FALSE
[01:29:28.210]    - call: NULL
[01:29:28.211] plan(): nbrOfWorkers() = 1
[01:29:28.212] plan(): Setting new future strategy stack:
[01:29:28.212] List of future strategies:
[01:29:28.212] 1. sequential:
[01:29:28.212]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.212]    - tweaked: FALSE
[01:29:28.212]    - call: plan(strategy)
[01:29:28.213] plan(): nbrOfWorkers() = 1
[01:29:28.213] SequentialFuture started (and completed)
[01:29:28.213] - Launch lazy future ... done
[01:29:28.213] run() for 'SequentialFuture' ... done
[[1]]
[1] 3

[[2]]
[1] 3

[[3]]
[1] 3

[[4]]
[1] 2

[01:29:28.215] getGlobalsAndPackages() ...
[01:29:28.215] Searching for globals...
[01:29:28.216] - globals found: [3] '{', 'sample', 'x'
[01:29:28.217] Searching for globals ... DONE
[01:29:28.218] Resolving globals: FALSE
[01:29:28.218] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.219] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.219] - globals: [1] 'x'
[01:29:28.219] 
[01:29:28.219] getGlobalsAndPackages() ... DONE
[01:29:28.220] run() for 'Future' ...
[01:29:28.220] - state: 'created'
[01:29:28.220] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.220] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.221] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.221]   - Field: 'label'
[01:29:28.221]   - Field: 'local'
[01:29:28.221]   - Field: 'owner'
[01:29:28.221]   - Field: 'envir'
[01:29:28.222]   - Field: 'packages'
[01:29:28.222]   - Field: 'gc'
[01:29:28.222]   - Field: 'conditions'
[01:29:28.222]   - Field: 'expr'
[01:29:28.222]   - Field: 'uuid'
[01:29:28.223]   - Field: 'seed'
[01:29:28.223]   - Field: 'version'
[01:29:28.223]   - Field: 'result'
[01:29:28.223]   - Field: 'asynchronous'
[01:29:28.223]   - Field: 'calls'
[01:29:28.223]   - Field: 'globals'
[01:29:28.224]   - Field: 'stdout'
[01:29:28.224]   - Field: 'earlySignal'
[01:29:28.224]   - Field: 'lazy'
[01:29:28.224]   - Field: 'state'
[01:29:28.224] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.225] - Launch lazy future ...
[01:29:28.225] Packages needed by the future expression (n = 0): <none>
[01:29:28.225] Packages needed by future strategies (n = 0): <none>
[01:29:28.226] {
[01:29:28.226]     {
[01:29:28.226]         {
[01:29:28.226]             ...future.startTime <- base::Sys.time()
[01:29:28.226]             {
[01:29:28.226]                 {
[01:29:28.226]                   {
[01:29:28.226]                     base::local({
[01:29:28.226]                       has_future <- base::requireNamespace("future", 
[01:29:28.226]                         quietly = TRUE)
[01:29:28.226]                       if (has_future) {
[01:29:28.226]                         ns <- base::getNamespace("future")
[01:29:28.226]                         version <- ns[[".package"]][["version"]]
[01:29:28.226]                         if (is.null(version)) 
[01:29:28.226]                           version <- utils::packageVersion("future")
[01:29:28.226]                       }
[01:29:28.226]                       else {
[01:29:28.226]                         version <- NULL
[01:29:28.226]                       }
[01:29:28.226]                       if (!has_future || version < "1.8.0") {
[01:29:28.226]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.226]                           "", base::R.version$version.string), 
[01:29:28.226]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.226]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.226]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.226]                             "release", "version")], collapse = " "), 
[01:29:28.226]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.226]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.226]                           info)
[01:29:28.226]                         info <- base::paste(info, collapse = "; ")
[01:29:28.226]                         if (!has_future) {
[01:29:28.226]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.226]                             info)
[01:29:28.226]                         }
[01:29:28.226]                         else {
[01:29:28.226]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.226]                             info, version)
[01:29:28.226]                         }
[01:29:28.226]                         base::stop(msg)
[01:29:28.226]                       }
[01:29:28.226]                     })
[01:29:28.226]                   }
[01:29:28.226]                   options(future.plan = NULL)
[01:29:28.226]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.226]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.226]                 }
[01:29:28.226]                 ...future.workdir <- getwd()
[01:29:28.226]             }
[01:29:28.226]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.226]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.226]         }
[01:29:28.226]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.226]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.226]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.226]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.226]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.226]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.226]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.226]             base::names(...future.oldOptions))
[01:29:28.226]     }
[01:29:28.226]     if (FALSE) {
[01:29:28.226]     }
[01:29:28.226]     else {
[01:29:28.226]         if (TRUE) {
[01:29:28.226]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.226]                 open = "w")
[01:29:28.226]         }
[01:29:28.226]         else {
[01:29:28.226]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.226]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.226]         }
[01:29:28.226]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.226]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.226]             base::sink(type = "output", split = FALSE)
[01:29:28.226]             base::close(...future.stdout)
[01:29:28.226]         }, add = TRUE)
[01:29:28.226]     }
[01:29:28.226]     ...future.frame <- base::sys.nframe()
[01:29:28.226]     ...future.conditions <- base::list()
[01:29:28.226]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.226]     if (FALSE) {
[01:29:28.226]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.226]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.226]     }
[01:29:28.226]     ...future.result <- base::tryCatch({
[01:29:28.226]         base::withCallingHandlers({
[01:29:28.226]             ...future.value <- base::withVisible(base::local({
[01:29:28.226]                 sample(x, size = 1L)
[01:29:28.226]             }))
[01:29:28.226]             future::FutureResult(value = ...future.value$value, 
[01:29:28.226]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.226]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.226]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.226]                     ...future.globalenv.names))
[01:29:28.226]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.226]         }, condition = base::local({
[01:29:28.226]             c <- base::c
[01:29:28.226]             inherits <- base::inherits
[01:29:28.226]             invokeRestart <- base::invokeRestart
[01:29:28.226]             length <- base::length
[01:29:28.226]             list <- base::list
[01:29:28.226]             seq.int <- base::seq.int
[01:29:28.226]             signalCondition <- base::signalCondition
[01:29:28.226]             sys.calls <- base::sys.calls
[01:29:28.226]             `[[` <- base::`[[`
[01:29:28.226]             `+` <- base::`+`
[01:29:28.226]             `<<-` <- base::`<<-`
[01:29:28.226]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.226]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.226]                   3L)]
[01:29:28.226]             }
[01:29:28.226]             function(cond) {
[01:29:28.226]                 is_error <- inherits(cond, "error")
[01:29:28.226]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.226]                   NULL)
[01:29:28.226]                 if (is_error) {
[01:29:28.226]                   sessionInformation <- function() {
[01:29:28.226]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.226]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.226]                       search = base::search(), system = base::Sys.info())
[01:29:28.226]                   }
[01:29:28.226]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.226]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.226]                     cond$call), session = sessionInformation(), 
[01:29:28.226]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.226]                   signalCondition(cond)
[01:29:28.226]                 }
[01:29:28.226]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.226]                 "immediateCondition"))) {
[01:29:28.226]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.226]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.226]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.226]                   if (TRUE && !signal) {
[01:29:28.226]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.226]                     {
[01:29:28.226]                       inherits <- base::inherits
[01:29:28.226]                       invokeRestart <- base::invokeRestart
[01:29:28.226]                       is.null <- base::is.null
[01:29:28.226]                       muffled <- FALSE
[01:29:28.226]                       if (inherits(cond, "message")) {
[01:29:28.226]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.226]                         if (muffled) 
[01:29:28.226]                           invokeRestart("muffleMessage")
[01:29:28.226]                       }
[01:29:28.226]                       else if (inherits(cond, "warning")) {
[01:29:28.226]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.226]                         if (muffled) 
[01:29:28.226]                           invokeRestart("muffleWarning")
[01:29:28.226]                       }
[01:29:28.226]                       else if (inherits(cond, "condition")) {
[01:29:28.226]                         if (!is.null(pattern)) {
[01:29:28.226]                           computeRestarts <- base::computeRestarts
[01:29:28.226]                           grepl <- base::grepl
[01:29:28.226]                           restarts <- computeRestarts(cond)
[01:29:28.226]                           for (restart in restarts) {
[01:29:28.226]                             name <- restart$name
[01:29:28.226]                             if (is.null(name)) 
[01:29:28.226]                               next
[01:29:28.226]                             if (!grepl(pattern, name)) 
[01:29:28.226]                               next
[01:29:28.226]                             invokeRestart(restart)
[01:29:28.226]                             muffled <- TRUE
[01:29:28.226]                             break
[01:29:28.226]                           }
[01:29:28.226]                         }
[01:29:28.226]                       }
[01:29:28.226]                       invisible(muffled)
[01:29:28.226]                     }
[01:29:28.226]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.226]                   }
[01:29:28.226]                 }
[01:29:28.226]                 else {
[01:29:28.226]                   if (TRUE) {
[01:29:28.226]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.226]                     {
[01:29:28.226]                       inherits <- base::inherits
[01:29:28.226]                       invokeRestart <- base::invokeRestart
[01:29:28.226]                       is.null <- base::is.null
[01:29:28.226]                       muffled <- FALSE
[01:29:28.226]                       if (inherits(cond, "message")) {
[01:29:28.226]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.226]                         if (muffled) 
[01:29:28.226]                           invokeRestart("muffleMessage")
[01:29:28.226]                       }
[01:29:28.226]                       else if (inherits(cond, "warning")) {
[01:29:28.226]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.226]                         if (muffled) 
[01:29:28.226]                           invokeRestart("muffleWarning")
[01:29:28.226]                       }
[01:29:28.226]                       else if (inherits(cond, "condition")) {
[01:29:28.226]                         if (!is.null(pattern)) {
[01:29:28.226]                           computeRestarts <- base::computeRestarts
[01:29:28.226]                           grepl <- base::grepl
[01:29:28.226]                           restarts <- computeRestarts(cond)
[01:29:28.226]                           for (restart in restarts) {
[01:29:28.226]                             name <- restart$name
[01:29:28.226]                             if (is.null(name)) 
[01:29:28.226]                               next
[01:29:28.226]                             if (!grepl(pattern, name)) 
[01:29:28.226]                               next
[01:29:28.226]                             invokeRestart(restart)
[01:29:28.226]                             muffled <- TRUE
[01:29:28.226]                             break
[01:29:28.226]                           }
[01:29:28.226]                         }
[01:29:28.226]                       }
[01:29:28.226]                       invisible(muffled)
[01:29:28.226]                     }
[01:29:28.226]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.226]                   }
[01:29:28.226]                 }
[01:29:28.226]             }
[01:29:28.226]         }))
[01:29:28.226]     }, error = function(ex) {
[01:29:28.226]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.226]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.226]                 ...future.rng), started = ...future.startTime, 
[01:29:28.226]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.226]             version = "1.8"), class = "FutureResult")
[01:29:28.226]     }, finally = {
[01:29:28.226]         if (!identical(...future.workdir, getwd())) 
[01:29:28.226]             setwd(...future.workdir)
[01:29:28.226]         {
[01:29:28.226]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.226]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.226]             }
[01:29:28.226]             base::options(...future.oldOptions)
[01:29:28.226]             if (.Platform$OS.type == "windows") {
[01:29:28.226]                 old_names <- names(...future.oldEnvVars)
[01:29:28.226]                 envs <- base::Sys.getenv()
[01:29:28.226]                 names <- names(envs)
[01:29:28.226]                 common <- intersect(names, old_names)
[01:29:28.226]                 added <- setdiff(names, old_names)
[01:29:28.226]                 removed <- setdiff(old_names, names)
[01:29:28.226]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.226]                   envs[common]]
[01:29:28.226]                 NAMES <- toupper(changed)
[01:29:28.226]                 args <- list()
[01:29:28.226]                 for (kk in seq_along(NAMES)) {
[01:29:28.226]                   name <- changed[[kk]]
[01:29:28.226]                   NAME <- NAMES[[kk]]
[01:29:28.226]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.226]                     next
[01:29:28.226]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.226]                 }
[01:29:28.226]                 NAMES <- toupper(added)
[01:29:28.226]                 for (kk in seq_along(NAMES)) {
[01:29:28.226]                   name <- added[[kk]]
[01:29:28.226]                   NAME <- NAMES[[kk]]
[01:29:28.226]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.226]                     next
[01:29:28.226]                   args[[name]] <- ""
[01:29:28.226]                 }
[01:29:28.226]                 NAMES <- toupper(removed)
[01:29:28.226]                 for (kk in seq_along(NAMES)) {
[01:29:28.226]                   name <- removed[[kk]]
[01:29:28.226]                   NAME <- NAMES[[kk]]
[01:29:28.226]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.226]                     next
[01:29:28.226]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.226]                 }
[01:29:28.226]                 if (length(args) > 0) 
[01:29:28.226]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.226]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.226]             }
[01:29:28.226]             else {
[01:29:28.226]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.226]             }
[01:29:28.226]             {
[01:29:28.226]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.226]                   0L) {
[01:29:28.226]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.226]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.226]                   base::options(opts)
[01:29:28.226]                 }
[01:29:28.226]                 {
[01:29:28.226]                   {
[01:29:28.226]                     base::assign(".Random.seed", c(10407L, 1320995057L, 
[01:29:28.226]                     -375345455L, 69301104L, 234633084L, 615948819L, 
[01:29:28.226]                     -1697938701L), envir = base::globalenv(), 
[01:29:28.226]                       inherits = FALSE)
[01:29:28.226]                     NULL
[01:29:28.226]                   }
[01:29:28.226]                   options(future.plan = NULL)
[01:29:28.226]                   if (is.na(NA_character_)) 
[01:29:28.226]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.226]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.226]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.226]                   {
[01:29:28.226]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.226]                     if (!future$lazy) 
[01:29:28.226]                       future <- run(future)
[01:29:28.226]                     invisible(future)
[01:29:28.226]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.226]                 }
[01:29:28.226]             }
[01:29:28.226]         }
[01:29:28.226]     })
[01:29:28.226]     if (TRUE) {
[01:29:28.226]         base::sink(type = "output", split = FALSE)
[01:29:28.226]         if (TRUE) {
[01:29:28.226]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.226]         }
[01:29:28.226]         else {
[01:29:28.226]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.226]         }
[01:29:28.226]         base::close(...future.stdout)
[01:29:28.226]         ...future.stdout <- NULL
[01:29:28.226]     }
[01:29:28.226]     ...future.result$conditions <- ...future.conditions
[01:29:28.226]     ...future.result$finished <- base::Sys.time()
[01:29:28.226]     ...future.result
[01:29:28.226] }
[01:29:28.229] assign_globals() ...
[01:29:28.230] List of 1
[01:29:28.230]  $ x: int [1:4] 0 1 2 3
[01:29:28.230]  - attr(*, "where")=List of 1
[01:29:28.230]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.230]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.230]  - attr(*, "resolved")= logi FALSE
[01:29:28.230]  - attr(*, "total_size")= num 64
[01:29:28.230]  - attr(*, "already-done")= logi TRUE
[01:29:28.233] - copied 'x' to environment
[01:29:28.233] assign_globals() ... done
[01:29:28.233] plan(): Setting new future strategy stack:
[01:29:28.233] List of future strategies:
[01:29:28.233] 1. sequential:
[01:29:28.233]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.233]    - tweaked: FALSE
[01:29:28.233]    - call: NULL
[01:29:28.234] plan(): nbrOfWorkers() = 1
[01:29:28.235] plan(): Setting new future strategy stack:
[01:29:28.235] List of future strategies:
[01:29:28.235] 1. sequential:
[01:29:28.235]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.235]    - tweaked: FALSE
[01:29:28.235]    - call: plan(strategy)
[01:29:28.236] plan(): nbrOfWorkers() = 1
[01:29:28.236] SequentialFuture started (and completed)
[01:29:28.237] - Launch lazy future ... done
[01:29:28.237] run() for 'SequentialFuture' ... done
[01:29:28.237] getGlobalsAndPackages() ...
[01:29:28.238] Searching for globals...
[01:29:28.239] - globals found: [3] '{', 'sample', 'x'
[01:29:28.239] Searching for globals ... DONE
[01:29:28.239] Resolving globals: FALSE
[01:29:28.240] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.240] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.240] - globals: [1] 'x'
[01:29:28.240] 
[01:29:28.241] getGlobalsAndPackages() ... DONE
[01:29:28.241] run() for 'Future' ...
[01:29:28.241] - state: 'created'
[01:29:28.241] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.242] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.242] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.242]   - Field: 'label'
[01:29:28.242]   - Field: 'local'
[01:29:28.242]   - Field: 'owner'
[01:29:28.243]   - Field: 'envir'
[01:29:28.243]   - Field: 'packages'
[01:29:28.243]   - Field: 'gc'
[01:29:28.243]   - Field: 'conditions'
[01:29:28.243]   - Field: 'expr'
[01:29:28.244]   - Field: 'uuid'
[01:29:28.244]   - Field: 'seed'
[01:29:28.244]   - Field: 'version'
[01:29:28.244]   - Field: 'result'
[01:29:28.244]   - Field: 'asynchronous'
[01:29:28.244]   - Field: 'calls'
[01:29:28.245]   - Field: 'globals'
[01:29:28.245]   - Field: 'stdout'
[01:29:28.245]   - Field: 'earlySignal'
[01:29:28.245]   - Field: 'lazy'
[01:29:28.245]   - Field: 'state'
[01:29:28.246] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.246] - Launch lazy future ...
[01:29:28.246] Packages needed by the future expression (n = 0): <none>
[01:29:28.246] Packages needed by future strategies (n = 0): <none>
[01:29:28.247] {
[01:29:28.247]     {
[01:29:28.247]         {
[01:29:28.247]             ...future.startTime <- base::Sys.time()
[01:29:28.247]             {
[01:29:28.247]                 {
[01:29:28.247]                   {
[01:29:28.247]                     base::local({
[01:29:28.247]                       has_future <- base::requireNamespace("future", 
[01:29:28.247]                         quietly = TRUE)
[01:29:28.247]                       if (has_future) {
[01:29:28.247]                         ns <- base::getNamespace("future")
[01:29:28.247]                         version <- ns[[".package"]][["version"]]
[01:29:28.247]                         if (is.null(version)) 
[01:29:28.247]                           version <- utils::packageVersion("future")
[01:29:28.247]                       }
[01:29:28.247]                       else {
[01:29:28.247]                         version <- NULL
[01:29:28.247]                       }
[01:29:28.247]                       if (!has_future || version < "1.8.0") {
[01:29:28.247]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.247]                           "", base::R.version$version.string), 
[01:29:28.247]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.247]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.247]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.247]                             "release", "version")], collapse = " "), 
[01:29:28.247]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.247]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.247]                           info)
[01:29:28.247]                         info <- base::paste(info, collapse = "; ")
[01:29:28.247]                         if (!has_future) {
[01:29:28.247]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.247]                             info)
[01:29:28.247]                         }
[01:29:28.247]                         else {
[01:29:28.247]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.247]                             info, version)
[01:29:28.247]                         }
[01:29:28.247]                         base::stop(msg)
[01:29:28.247]                       }
[01:29:28.247]                     })
[01:29:28.247]                   }
[01:29:28.247]                   options(future.plan = NULL)
[01:29:28.247]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.247]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.247]                 }
[01:29:28.247]                 ...future.workdir <- getwd()
[01:29:28.247]             }
[01:29:28.247]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.247]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.247]         }
[01:29:28.247]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.247]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.247]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.247]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.247]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.247]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.247]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.247]             base::names(...future.oldOptions))
[01:29:28.247]     }
[01:29:28.247]     if (FALSE) {
[01:29:28.247]     }
[01:29:28.247]     else {
[01:29:28.247]         if (TRUE) {
[01:29:28.247]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.247]                 open = "w")
[01:29:28.247]         }
[01:29:28.247]         else {
[01:29:28.247]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.247]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.247]         }
[01:29:28.247]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.247]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.247]             base::sink(type = "output", split = FALSE)
[01:29:28.247]             base::close(...future.stdout)
[01:29:28.247]         }, add = TRUE)
[01:29:28.247]     }
[01:29:28.247]     ...future.frame <- base::sys.nframe()
[01:29:28.247]     ...future.conditions <- base::list()
[01:29:28.247]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.247]     if (FALSE) {
[01:29:28.247]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.247]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.247]     }
[01:29:28.247]     ...future.result <- base::tryCatch({
[01:29:28.247]         base::withCallingHandlers({
[01:29:28.247]             ...future.value <- base::withVisible(base::local({
[01:29:28.247]                 sample(x, size = 1L)
[01:29:28.247]             }))
[01:29:28.247]             future::FutureResult(value = ...future.value$value, 
[01:29:28.247]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.247]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.247]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.247]                     ...future.globalenv.names))
[01:29:28.247]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.247]         }, condition = base::local({
[01:29:28.247]             c <- base::c
[01:29:28.247]             inherits <- base::inherits
[01:29:28.247]             invokeRestart <- base::invokeRestart
[01:29:28.247]             length <- base::length
[01:29:28.247]             list <- base::list
[01:29:28.247]             seq.int <- base::seq.int
[01:29:28.247]             signalCondition <- base::signalCondition
[01:29:28.247]             sys.calls <- base::sys.calls
[01:29:28.247]             `[[` <- base::`[[`
[01:29:28.247]             `+` <- base::`+`
[01:29:28.247]             `<<-` <- base::`<<-`
[01:29:28.247]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.247]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.247]                   3L)]
[01:29:28.247]             }
[01:29:28.247]             function(cond) {
[01:29:28.247]                 is_error <- inherits(cond, "error")
[01:29:28.247]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.247]                   NULL)
[01:29:28.247]                 if (is_error) {
[01:29:28.247]                   sessionInformation <- function() {
[01:29:28.247]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.247]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.247]                       search = base::search(), system = base::Sys.info())
[01:29:28.247]                   }
[01:29:28.247]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.247]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.247]                     cond$call), session = sessionInformation(), 
[01:29:28.247]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.247]                   signalCondition(cond)
[01:29:28.247]                 }
[01:29:28.247]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.247]                 "immediateCondition"))) {
[01:29:28.247]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.247]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.247]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.247]                   if (TRUE && !signal) {
[01:29:28.247]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.247]                     {
[01:29:28.247]                       inherits <- base::inherits
[01:29:28.247]                       invokeRestart <- base::invokeRestart
[01:29:28.247]                       is.null <- base::is.null
[01:29:28.247]                       muffled <- FALSE
[01:29:28.247]                       if (inherits(cond, "message")) {
[01:29:28.247]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.247]                         if (muffled) 
[01:29:28.247]                           invokeRestart("muffleMessage")
[01:29:28.247]                       }
[01:29:28.247]                       else if (inherits(cond, "warning")) {
[01:29:28.247]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.247]                         if (muffled) 
[01:29:28.247]                           invokeRestart("muffleWarning")
[01:29:28.247]                       }
[01:29:28.247]                       else if (inherits(cond, "condition")) {
[01:29:28.247]                         if (!is.null(pattern)) {
[01:29:28.247]                           computeRestarts <- base::computeRestarts
[01:29:28.247]                           grepl <- base::grepl
[01:29:28.247]                           restarts <- computeRestarts(cond)
[01:29:28.247]                           for (restart in restarts) {
[01:29:28.247]                             name <- restart$name
[01:29:28.247]                             if (is.null(name)) 
[01:29:28.247]                               next
[01:29:28.247]                             if (!grepl(pattern, name)) 
[01:29:28.247]                               next
[01:29:28.247]                             invokeRestart(restart)
[01:29:28.247]                             muffled <- TRUE
[01:29:28.247]                             break
[01:29:28.247]                           }
[01:29:28.247]                         }
[01:29:28.247]                       }
[01:29:28.247]                       invisible(muffled)
[01:29:28.247]                     }
[01:29:28.247]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.247]                   }
[01:29:28.247]                 }
[01:29:28.247]                 else {
[01:29:28.247]                   if (TRUE) {
[01:29:28.247]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.247]                     {
[01:29:28.247]                       inherits <- base::inherits
[01:29:28.247]                       invokeRestart <- base::invokeRestart
[01:29:28.247]                       is.null <- base::is.null
[01:29:28.247]                       muffled <- FALSE
[01:29:28.247]                       if (inherits(cond, "message")) {
[01:29:28.247]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.247]                         if (muffled) 
[01:29:28.247]                           invokeRestart("muffleMessage")
[01:29:28.247]                       }
[01:29:28.247]                       else if (inherits(cond, "warning")) {
[01:29:28.247]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.247]                         if (muffled) 
[01:29:28.247]                           invokeRestart("muffleWarning")
[01:29:28.247]                       }
[01:29:28.247]                       else if (inherits(cond, "condition")) {
[01:29:28.247]                         if (!is.null(pattern)) {
[01:29:28.247]                           computeRestarts <- base::computeRestarts
[01:29:28.247]                           grepl <- base::grepl
[01:29:28.247]                           restarts <- computeRestarts(cond)
[01:29:28.247]                           for (restart in restarts) {
[01:29:28.247]                             name <- restart$name
[01:29:28.247]                             if (is.null(name)) 
[01:29:28.247]                               next
[01:29:28.247]                             if (!grepl(pattern, name)) 
[01:29:28.247]                               next
[01:29:28.247]                             invokeRestart(restart)
[01:29:28.247]                             muffled <- TRUE
[01:29:28.247]                             break
[01:29:28.247]                           }
[01:29:28.247]                         }
[01:29:28.247]                       }
[01:29:28.247]                       invisible(muffled)
[01:29:28.247]                     }
[01:29:28.247]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.247]                   }
[01:29:28.247]                 }
[01:29:28.247]             }
[01:29:28.247]         }))
[01:29:28.247]     }, error = function(ex) {
[01:29:28.247]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.247]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.247]                 ...future.rng), started = ...future.startTime, 
[01:29:28.247]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.247]             version = "1.8"), class = "FutureResult")
[01:29:28.247]     }, finally = {
[01:29:28.247]         if (!identical(...future.workdir, getwd())) 
[01:29:28.247]             setwd(...future.workdir)
[01:29:28.247]         {
[01:29:28.247]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.247]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.247]             }
[01:29:28.247]             base::options(...future.oldOptions)
[01:29:28.247]             if (.Platform$OS.type == "windows") {
[01:29:28.247]                 old_names <- names(...future.oldEnvVars)
[01:29:28.247]                 envs <- base::Sys.getenv()
[01:29:28.247]                 names <- names(envs)
[01:29:28.247]                 common <- intersect(names, old_names)
[01:29:28.247]                 added <- setdiff(names, old_names)
[01:29:28.247]                 removed <- setdiff(old_names, names)
[01:29:28.247]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.247]                   envs[common]]
[01:29:28.247]                 NAMES <- toupper(changed)
[01:29:28.247]                 args <- list()
[01:29:28.247]                 for (kk in seq_along(NAMES)) {
[01:29:28.247]                   name <- changed[[kk]]
[01:29:28.247]                   NAME <- NAMES[[kk]]
[01:29:28.247]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.247]                     next
[01:29:28.247]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.247]                 }
[01:29:28.247]                 NAMES <- toupper(added)
[01:29:28.247]                 for (kk in seq_along(NAMES)) {
[01:29:28.247]                   name <- added[[kk]]
[01:29:28.247]                   NAME <- NAMES[[kk]]
[01:29:28.247]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.247]                     next
[01:29:28.247]                   args[[name]] <- ""
[01:29:28.247]                 }
[01:29:28.247]                 NAMES <- toupper(removed)
[01:29:28.247]                 for (kk in seq_along(NAMES)) {
[01:29:28.247]                   name <- removed[[kk]]
[01:29:28.247]                   NAME <- NAMES[[kk]]
[01:29:28.247]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.247]                     next
[01:29:28.247]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.247]                 }
[01:29:28.247]                 if (length(args) > 0) 
[01:29:28.247]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.247]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.247]             }
[01:29:28.247]             else {
[01:29:28.247]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.247]             }
[01:29:28.247]             {
[01:29:28.247]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.247]                   0L) {
[01:29:28.247]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.247]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.247]                   base::options(opts)
[01:29:28.247]                 }
[01:29:28.247]                 {
[01:29:28.247]                   {
[01:29:28.247]                     base::assign(".Random.seed", c(10407L, 1711451082L, 
[01:29:28.247]                     -154467960L, 1752249982L, -183923976L, 802413990L, 
[01:29:28.247]                     -1367522548L), envir = base::globalenv(), 
[01:29:28.247]                       inherits = FALSE)
[01:29:28.247]                     NULL
[01:29:28.247]                   }
[01:29:28.247]                   options(future.plan = NULL)
[01:29:28.247]                   if (is.na(NA_character_)) 
[01:29:28.247]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.247]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.247]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.247]                   {
[01:29:28.247]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.247]                     if (!future$lazy) 
[01:29:28.247]                       future <- run(future)
[01:29:28.247]                     invisible(future)
[01:29:28.247]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.247]                 }
[01:29:28.247]             }
[01:29:28.247]         }
[01:29:28.247]     })
[01:29:28.247]     if (TRUE) {
[01:29:28.247]         base::sink(type = "output", split = FALSE)
[01:29:28.247]         if (TRUE) {
[01:29:28.247]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.247]         }
[01:29:28.247]         else {
[01:29:28.247]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.247]         }
[01:29:28.247]         base::close(...future.stdout)
[01:29:28.247]         ...future.stdout <- NULL
[01:29:28.247]     }
[01:29:28.247]     ...future.result$conditions <- ...future.conditions
[01:29:28.247]     ...future.result$finished <- base::Sys.time()
[01:29:28.247]     ...future.result
[01:29:28.247] }
[01:29:28.250] assign_globals() ...
[01:29:28.251] List of 1
[01:29:28.251]  $ x: int [1:4] 0 1 2 3
[01:29:28.251]  - attr(*, "where")=List of 1
[01:29:28.251]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.251]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.251]  - attr(*, "resolved")= logi FALSE
[01:29:28.251]  - attr(*, "total_size")= num 64
[01:29:28.251]  - attr(*, "already-done")= logi TRUE
[01:29:28.255] - copied 'x' to environment
[01:29:28.256] assign_globals() ... done
[01:29:28.256] plan(): Setting new future strategy stack:
[01:29:28.256] List of future strategies:
[01:29:28.256] 1. sequential:
[01:29:28.256]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.256]    - tweaked: FALSE
[01:29:28.256]    - call: NULL
[01:29:28.257] plan(): nbrOfWorkers() = 1
[01:29:28.258] plan(): Setting new future strategy stack:
[01:29:28.258] List of future strategies:
[01:29:28.258] 1. sequential:
[01:29:28.258]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.258]    - tweaked: FALSE
[01:29:28.258]    - call: plan(strategy)
[01:29:28.259] plan(): nbrOfWorkers() = 1
[01:29:28.259] SequentialFuture started (and completed)
[01:29:28.259] - Launch lazy future ... done
[01:29:28.259] run() for 'SequentialFuture' ... done
[01:29:28.260] getGlobalsAndPackages() ...
[01:29:28.260] Searching for globals...
[01:29:28.261] - globals found: [3] '{', 'sample', 'x'
[01:29:28.261] Searching for globals ... DONE
[01:29:28.262] Resolving globals: FALSE
[01:29:28.262] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.263] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.263] - globals: [1] 'x'
[01:29:28.263] 
[01:29:28.263] getGlobalsAndPackages() ... DONE
[01:29:28.263] run() for 'Future' ...
[01:29:28.264] - state: 'created'
[01:29:28.264] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.264] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.264] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.264]   - Field: 'label'
[01:29:28.265]   - Field: 'local'
[01:29:28.265]   - Field: 'owner'
[01:29:28.265]   - Field: 'envir'
[01:29:28.265]   - Field: 'packages'
[01:29:28.265]   - Field: 'gc'
[01:29:28.266]   - Field: 'conditions'
[01:29:28.266]   - Field: 'expr'
[01:29:28.266]   - Field: 'uuid'
[01:29:28.266]   - Field: 'seed'
[01:29:28.266]   - Field: 'version'
[01:29:28.266]   - Field: 'result'
[01:29:28.267]   - Field: 'asynchronous'
[01:29:28.267]   - Field: 'calls'
[01:29:28.267]   - Field: 'globals'
[01:29:28.267]   - Field: 'stdout'
[01:29:28.267]   - Field: 'earlySignal'
[01:29:28.267]   - Field: 'lazy'
[01:29:28.268]   - Field: 'state'
[01:29:28.268] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.268] - Launch lazy future ...
[01:29:28.268] Packages needed by the future expression (n = 0): <none>
[01:29:28.268] Packages needed by future strategies (n = 0): <none>
[01:29:28.269] {
[01:29:28.269]     {
[01:29:28.269]         {
[01:29:28.269]             ...future.startTime <- base::Sys.time()
[01:29:28.269]             {
[01:29:28.269]                 {
[01:29:28.269]                   {
[01:29:28.269]                     base::local({
[01:29:28.269]                       has_future <- base::requireNamespace("future", 
[01:29:28.269]                         quietly = TRUE)
[01:29:28.269]                       if (has_future) {
[01:29:28.269]                         ns <- base::getNamespace("future")
[01:29:28.269]                         version <- ns[[".package"]][["version"]]
[01:29:28.269]                         if (is.null(version)) 
[01:29:28.269]                           version <- utils::packageVersion("future")
[01:29:28.269]                       }
[01:29:28.269]                       else {
[01:29:28.269]                         version <- NULL
[01:29:28.269]                       }
[01:29:28.269]                       if (!has_future || version < "1.8.0") {
[01:29:28.269]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.269]                           "", base::R.version$version.string), 
[01:29:28.269]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.269]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.269]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.269]                             "release", "version")], collapse = " "), 
[01:29:28.269]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.269]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.269]                           info)
[01:29:28.269]                         info <- base::paste(info, collapse = "; ")
[01:29:28.269]                         if (!has_future) {
[01:29:28.269]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.269]                             info)
[01:29:28.269]                         }
[01:29:28.269]                         else {
[01:29:28.269]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.269]                             info, version)
[01:29:28.269]                         }
[01:29:28.269]                         base::stop(msg)
[01:29:28.269]                       }
[01:29:28.269]                     })
[01:29:28.269]                   }
[01:29:28.269]                   options(future.plan = NULL)
[01:29:28.269]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.269]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.269]                 }
[01:29:28.269]                 ...future.workdir <- getwd()
[01:29:28.269]             }
[01:29:28.269]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.269]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.269]         }
[01:29:28.269]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.269]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.269]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.269]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.269]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.269]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.269]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.269]             base::names(...future.oldOptions))
[01:29:28.269]     }
[01:29:28.269]     if (FALSE) {
[01:29:28.269]     }
[01:29:28.269]     else {
[01:29:28.269]         if (TRUE) {
[01:29:28.269]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.269]                 open = "w")
[01:29:28.269]         }
[01:29:28.269]         else {
[01:29:28.269]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.269]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.269]         }
[01:29:28.269]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.269]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.269]             base::sink(type = "output", split = FALSE)
[01:29:28.269]             base::close(...future.stdout)
[01:29:28.269]         }, add = TRUE)
[01:29:28.269]     }
[01:29:28.269]     ...future.frame <- base::sys.nframe()
[01:29:28.269]     ...future.conditions <- base::list()
[01:29:28.269]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.269]     if (FALSE) {
[01:29:28.269]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.269]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.269]     }
[01:29:28.269]     ...future.result <- base::tryCatch({
[01:29:28.269]         base::withCallingHandlers({
[01:29:28.269]             ...future.value <- base::withVisible(base::local({
[01:29:28.269]                 sample(x, size = 1L)
[01:29:28.269]             }))
[01:29:28.269]             future::FutureResult(value = ...future.value$value, 
[01:29:28.269]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.269]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.269]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.269]                     ...future.globalenv.names))
[01:29:28.269]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.269]         }, condition = base::local({
[01:29:28.269]             c <- base::c
[01:29:28.269]             inherits <- base::inherits
[01:29:28.269]             invokeRestart <- base::invokeRestart
[01:29:28.269]             length <- base::length
[01:29:28.269]             list <- base::list
[01:29:28.269]             seq.int <- base::seq.int
[01:29:28.269]             signalCondition <- base::signalCondition
[01:29:28.269]             sys.calls <- base::sys.calls
[01:29:28.269]             `[[` <- base::`[[`
[01:29:28.269]             `+` <- base::`+`
[01:29:28.269]             `<<-` <- base::`<<-`
[01:29:28.269]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.269]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.269]                   3L)]
[01:29:28.269]             }
[01:29:28.269]             function(cond) {
[01:29:28.269]                 is_error <- inherits(cond, "error")
[01:29:28.269]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.269]                   NULL)
[01:29:28.269]                 if (is_error) {
[01:29:28.269]                   sessionInformation <- function() {
[01:29:28.269]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.269]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.269]                       search = base::search(), system = base::Sys.info())
[01:29:28.269]                   }
[01:29:28.269]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.269]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.269]                     cond$call), session = sessionInformation(), 
[01:29:28.269]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.269]                   signalCondition(cond)
[01:29:28.269]                 }
[01:29:28.269]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.269]                 "immediateCondition"))) {
[01:29:28.269]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.269]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.269]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.269]                   if (TRUE && !signal) {
[01:29:28.269]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.269]                     {
[01:29:28.269]                       inherits <- base::inherits
[01:29:28.269]                       invokeRestart <- base::invokeRestart
[01:29:28.269]                       is.null <- base::is.null
[01:29:28.269]                       muffled <- FALSE
[01:29:28.269]                       if (inherits(cond, "message")) {
[01:29:28.269]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.269]                         if (muffled) 
[01:29:28.269]                           invokeRestart("muffleMessage")
[01:29:28.269]                       }
[01:29:28.269]                       else if (inherits(cond, "warning")) {
[01:29:28.269]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.269]                         if (muffled) 
[01:29:28.269]                           invokeRestart("muffleWarning")
[01:29:28.269]                       }
[01:29:28.269]                       else if (inherits(cond, "condition")) {
[01:29:28.269]                         if (!is.null(pattern)) {
[01:29:28.269]                           computeRestarts <- base::computeRestarts
[01:29:28.269]                           grepl <- base::grepl
[01:29:28.269]                           restarts <- computeRestarts(cond)
[01:29:28.269]                           for (restart in restarts) {
[01:29:28.269]                             name <- restart$name
[01:29:28.269]                             if (is.null(name)) 
[01:29:28.269]                               next
[01:29:28.269]                             if (!grepl(pattern, name)) 
[01:29:28.269]                               next
[01:29:28.269]                             invokeRestart(restart)
[01:29:28.269]                             muffled <- TRUE
[01:29:28.269]                             break
[01:29:28.269]                           }
[01:29:28.269]                         }
[01:29:28.269]                       }
[01:29:28.269]                       invisible(muffled)
[01:29:28.269]                     }
[01:29:28.269]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.269]                   }
[01:29:28.269]                 }
[01:29:28.269]                 else {
[01:29:28.269]                   if (TRUE) {
[01:29:28.269]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.269]                     {
[01:29:28.269]                       inherits <- base::inherits
[01:29:28.269]                       invokeRestart <- base::invokeRestart
[01:29:28.269]                       is.null <- base::is.null
[01:29:28.269]                       muffled <- FALSE
[01:29:28.269]                       if (inherits(cond, "message")) {
[01:29:28.269]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.269]                         if (muffled) 
[01:29:28.269]                           invokeRestart("muffleMessage")
[01:29:28.269]                       }
[01:29:28.269]                       else if (inherits(cond, "warning")) {
[01:29:28.269]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.269]                         if (muffled) 
[01:29:28.269]                           invokeRestart("muffleWarning")
[01:29:28.269]                       }
[01:29:28.269]                       else if (inherits(cond, "condition")) {
[01:29:28.269]                         if (!is.null(pattern)) {
[01:29:28.269]                           computeRestarts <- base::computeRestarts
[01:29:28.269]                           grepl <- base::grepl
[01:29:28.269]                           restarts <- computeRestarts(cond)
[01:29:28.269]                           for (restart in restarts) {
[01:29:28.269]                             name <- restart$name
[01:29:28.269]                             if (is.null(name)) 
[01:29:28.269]                               next
[01:29:28.269]                             if (!grepl(pattern, name)) 
[01:29:28.269]                               next
[01:29:28.269]                             invokeRestart(restart)
[01:29:28.269]                             muffled <- TRUE
[01:29:28.269]                             break
[01:29:28.269]                           }
[01:29:28.269]                         }
[01:29:28.269]                       }
[01:29:28.269]                       invisible(muffled)
[01:29:28.269]                     }
[01:29:28.269]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.269]                   }
[01:29:28.269]                 }
[01:29:28.269]             }
[01:29:28.269]         }))
[01:29:28.269]     }, error = function(ex) {
[01:29:28.269]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.269]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.269]                 ...future.rng), started = ...future.startTime, 
[01:29:28.269]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.269]             version = "1.8"), class = "FutureResult")
[01:29:28.269]     }, finally = {
[01:29:28.269]         if (!identical(...future.workdir, getwd())) 
[01:29:28.269]             setwd(...future.workdir)
[01:29:28.269]         {
[01:29:28.269]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.269]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.269]             }
[01:29:28.269]             base::options(...future.oldOptions)
[01:29:28.269]             if (.Platform$OS.type == "windows") {
[01:29:28.269]                 old_names <- names(...future.oldEnvVars)
[01:29:28.269]                 envs <- base::Sys.getenv()
[01:29:28.269]                 names <- names(envs)
[01:29:28.269]                 common <- intersect(names, old_names)
[01:29:28.269]                 added <- setdiff(names, old_names)
[01:29:28.269]                 removed <- setdiff(old_names, names)
[01:29:28.269]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.269]                   envs[common]]
[01:29:28.269]                 NAMES <- toupper(changed)
[01:29:28.269]                 args <- list()
[01:29:28.269]                 for (kk in seq_along(NAMES)) {
[01:29:28.269]                   name <- changed[[kk]]
[01:29:28.269]                   NAME <- NAMES[[kk]]
[01:29:28.269]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.269]                     next
[01:29:28.269]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.269]                 }
[01:29:28.269]                 NAMES <- toupper(added)
[01:29:28.269]                 for (kk in seq_along(NAMES)) {
[01:29:28.269]                   name <- added[[kk]]
[01:29:28.269]                   NAME <- NAMES[[kk]]
[01:29:28.269]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.269]                     next
[01:29:28.269]                   args[[name]] <- ""
[01:29:28.269]                 }
[01:29:28.269]                 NAMES <- toupper(removed)
[01:29:28.269]                 for (kk in seq_along(NAMES)) {
[01:29:28.269]                   name <- removed[[kk]]
[01:29:28.269]                   NAME <- NAMES[[kk]]
[01:29:28.269]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.269]                     next
[01:29:28.269]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.269]                 }
[01:29:28.269]                 if (length(args) > 0) 
[01:29:28.269]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.269]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.269]             }
[01:29:28.269]             else {
[01:29:28.269]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.269]             }
[01:29:28.269]             {
[01:29:28.269]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.269]                   0L) {
[01:29:28.269]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.269]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.269]                   base::options(opts)
[01:29:28.269]                 }
[01:29:28.269]                 {
[01:29:28.269]                   {
[01:29:28.269]                     base::assign(".Random.seed", c(10407L, 1752249982L, 
[01:29:28.269]                     -37979766L, -997816390L, -1367522548L, -1785432074L, 
[01:29:28.269]                     -889426559L), envir = base::globalenv(), 
[01:29:28.269]                       inherits = FALSE)
[01:29:28.269]                     NULL
[01:29:28.269]                   }
[01:29:28.269]                   options(future.plan = NULL)
[01:29:28.269]                   if (is.na(NA_character_)) 
[01:29:28.269]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.269]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.269]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.269]                   {
[01:29:28.269]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.269]                     if (!future$lazy) 
[01:29:28.269]                       future <- run(future)
[01:29:28.269]                     invisible(future)
[01:29:28.269]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.269]                 }
[01:29:28.269]             }
[01:29:28.269]         }
[01:29:28.269]     })
[01:29:28.269]     if (TRUE) {
[01:29:28.269]         base::sink(type = "output", split = FALSE)
[01:29:28.269]         if (TRUE) {
[01:29:28.269]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.269]         }
[01:29:28.269]         else {
[01:29:28.269]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.269]         }
[01:29:28.269]         base::close(...future.stdout)
[01:29:28.269]         ...future.stdout <- NULL
[01:29:28.269]     }
[01:29:28.269]     ...future.result$conditions <- ...future.conditions
[01:29:28.269]     ...future.result$finished <- base::Sys.time()
[01:29:28.269]     ...future.result
[01:29:28.269] }
[01:29:28.273] assign_globals() ...
[01:29:28.273] List of 1
[01:29:28.273]  $ x: int [1:4] 0 1 2 3
[01:29:28.273]  - attr(*, "where")=List of 1
[01:29:28.273]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.273]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.273]  - attr(*, "resolved")= logi FALSE
[01:29:28.273]  - attr(*, "total_size")= num 64
[01:29:28.273]  - attr(*, "already-done")= logi TRUE
[01:29:28.276] - copied 'x' to environment
[01:29:28.276] assign_globals() ... done
[01:29:28.277] plan(): Setting new future strategy stack:
[01:29:28.277] List of future strategies:
[01:29:28.277] 1. sequential:
[01:29:28.277]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.277]    - tweaked: FALSE
[01:29:28.277]    - call: NULL
[01:29:28.277] plan(): nbrOfWorkers() = 1
[01:29:28.279] plan(): Setting new future strategy stack:
[01:29:28.279] List of future strategies:
[01:29:28.279] 1. sequential:
[01:29:28.279]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.279]    - tweaked: FALSE
[01:29:28.279]    - call: plan(strategy)
[01:29:28.279] plan(): nbrOfWorkers() = 1
[01:29:28.280] SequentialFuture started (and completed)
[01:29:28.280] - Launch lazy future ... done
[01:29:28.280] run() for 'SequentialFuture' ... done
[01:29:28.281] getGlobalsAndPackages() ...
[01:29:28.281] Searching for globals...
[01:29:28.282] - globals found: [3] '{', 'sample', 'x'
[01:29:28.282] Searching for globals ... DONE
[01:29:28.282] Resolving globals: FALSE
[01:29:28.283] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.283] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.284] - globals: [1] 'x'
[01:29:28.284] 
[01:29:28.284] getGlobalsAndPackages() ... DONE
[01:29:28.284] run() for 'Future' ...
[01:29:28.284] - state: 'created'
[01:29:28.285] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.286] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.286] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.287]   - Field: 'label'
[01:29:28.287]   - Field: 'local'
[01:29:28.287]   - Field: 'owner'
[01:29:28.287]   - Field: 'envir'
[01:29:28.287]   - Field: 'packages'
[01:29:28.288]   - Field: 'gc'
[01:29:28.288]   - Field: 'conditions'
[01:29:28.288]   - Field: 'expr'
[01:29:28.288]   - Field: 'uuid'
[01:29:28.288]   - Field: 'seed'
[01:29:28.288]   - Field: 'version'
[01:29:28.289]   - Field: 'result'
[01:29:28.289]   - Field: 'asynchronous'
[01:29:28.289]   - Field: 'calls'
[01:29:28.289]   - Field: 'globals'
[01:29:28.289]   - Field: 'stdout'
[01:29:28.289]   - Field: 'earlySignal'
[01:29:28.290]   - Field: 'lazy'
[01:29:28.290]   - Field: 'state'
[01:29:28.290] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.290] - Launch lazy future ...
[01:29:28.290] Packages needed by the future expression (n = 0): <none>
[01:29:28.291] Packages needed by future strategies (n = 0): <none>
[01:29:28.291] {
[01:29:28.291]     {
[01:29:28.291]         {
[01:29:28.291]             ...future.startTime <- base::Sys.time()
[01:29:28.291]             {
[01:29:28.291]                 {
[01:29:28.291]                   {
[01:29:28.291]                     base::local({
[01:29:28.291]                       has_future <- base::requireNamespace("future", 
[01:29:28.291]                         quietly = TRUE)
[01:29:28.291]                       if (has_future) {
[01:29:28.291]                         ns <- base::getNamespace("future")
[01:29:28.291]                         version <- ns[[".package"]][["version"]]
[01:29:28.291]                         if (is.null(version)) 
[01:29:28.291]                           version <- utils::packageVersion("future")
[01:29:28.291]                       }
[01:29:28.291]                       else {
[01:29:28.291]                         version <- NULL
[01:29:28.291]                       }
[01:29:28.291]                       if (!has_future || version < "1.8.0") {
[01:29:28.291]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.291]                           "", base::R.version$version.string), 
[01:29:28.291]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.291]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.291]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.291]                             "release", "version")], collapse = " "), 
[01:29:28.291]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.291]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.291]                           info)
[01:29:28.291]                         info <- base::paste(info, collapse = "; ")
[01:29:28.291]                         if (!has_future) {
[01:29:28.291]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.291]                             info)
[01:29:28.291]                         }
[01:29:28.291]                         else {
[01:29:28.291]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.291]                             info, version)
[01:29:28.291]                         }
[01:29:28.291]                         base::stop(msg)
[01:29:28.291]                       }
[01:29:28.291]                     })
[01:29:28.291]                   }
[01:29:28.291]                   options(future.plan = NULL)
[01:29:28.291]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.291]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.291]                 }
[01:29:28.291]                 ...future.workdir <- getwd()
[01:29:28.291]             }
[01:29:28.291]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.291]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.291]         }
[01:29:28.291]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.291]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.291]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.291]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.291]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.291]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.291]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.291]             base::names(...future.oldOptions))
[01:29:28.291]     }
[01:29:28.291]     if (FALSE) {
[01:29:28.291]     }
[01:29:28.291]     else {
[01:29:28.291]         if (TRUE) {
[01:29:28.291]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.291]                 open = "w")
[01:29:28.291]         }
[01:29:28.291]         else {
[01:29:28.291]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.291]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.291]         }
[01:29:28.291]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.291]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.291]             base::sink(type = "output", split = FALSE)
[01:29:28.291]             base::close(...future.stdout)
[01:29:28.291]         }, add = TRUE)
[01:29:28.291]     }
[01:29:28.291]     ...future.frame <- base::sys.nframe()
[01:29:28.291]     ...future.conditions <- base::list()
[01:29:28.291]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.291]     if (FALSE) {
[01:29:28.291]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.291]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.291]     }
[01:29:28.291]     ...future.result <- base::tryCatch({
[01:29:28.291]         base::withCallingHandlers({
[01:29:28.291]             ...future.value <- base::withVisible(base::local({
[01:29:28.291]                 sample(x, size = 1L)
[01:29:28.291]             }))
[01:29:28.291]             future::FutureResult(value = ...future.value$value, 
[01:29:28.291]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.291]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.291]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.291]                     ...future.globalenv.names))
[01:29:28.291]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.291]         }, condition = base::local({
[01:29:28.291]             c <- base::c
[01:29:28.291]             inherits <- base::inherits
[01:29:28.291]             invokeRestart <- base::invokeRestart
[01:29:28.291]             length <- base::length
[01:29:28.291]             list <- base::list
[01:29:28.291]             seq.int <- base::seq.int
[01:29:28.291]             signalCondition <- base::signalCondition
[01:29:28.291]             sys.calls <- base::sys.calls
[01:29:28.291]             `[[` <- base::`[[`
[01:29:28.291]             `+` <- base::`+`
[01:29:28.291]             `<<-` <- base::`<<-`
[01:29:28.291]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.291]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.291]                   3L)]
[01:29:28.291]             }
[01:29:28.291]             function(cond) {
[01:29:28.291]                 is_error <- inherits(cond, "error")
[01:29:28.291]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.291]                   NULL)
[01:29:28.291]                 if (is_error) {
[01:29:28.291]                   sessionInformation <- function() {
[01:29:28.291]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.291]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.291]                       search = base::search(), system = base::Sys.info())
[01:29:28.291]                   }
[01:29:28.291]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.291]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.291]                     cond$call), session = sessionInformation(), 
[01:29:28.291]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.291]                   signalCondition(cond)
[01:29:28.291]                 }
[01:29:28.291]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.291]                 "immediateCondition"))) {
[01:29:28.291]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.291]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.291]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.291]                   if (TRUE && !signal) {
[01:29:28.291]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.291]                     {
[01:29:28.291]                       inherits <- base::inherits
[01:29:28.291]                       invokeRestart <- base::invokeRestart
[01:29:28.291]                       is.null <- base::is.null
[01:29:28.291]                       muffled <- FALSE
[01:29:28.291]                       if (inherits(cond, "message")) {
[01:29:28.291]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.291]                         if (muffled) 
[01:29:28.291]                           invokeRestart("muffleMessage")
[01:29:28.291]                       }
[01:29:28.291]                       else if (inherits(cond, "warning")) {
[01:29:28.291]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.291]                         if (muffled) 
[01:29:28.291]                           invokeRestart("muffleWarning")
[01:29:28.291]                       }
[01:29:28.291]                       else if (inherits(cond, "condition")) {
[01:29:28.291]                         if (!is.null(pattern)) {
[01:29:28.291]                           computeRestarts <- base::computeRestarts
[01:29:28.291]                           grepl <- base::grepl
[01:29:28.291]                           restarts <- computeRestarts(cond)
[01:29:28.291]                           for (restart in restarts) {
[01:29:28.291]                             name <- restart$name
[01:29:28.291]                             if (is.null(name)) 
[01:29:28.291]                               next
[01:29:28.291]                             if (!grepl(pattern, name)) 
[01:29:28.291]                               next
[01:29:28.291]                             invokeRestart(restart)
[01:29:28.291]                             muffled <- TRUE
[01:29:28.291]                             break
[01:29:28.291]                           }
[01:29:28.291]                         }
[01:29:28.291]                       }
[01:29:28.291]                       invisible(muffled)
[01:29:28.291]                     }
[01:29:28.291]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.291]                   }
[01:29:28.291]                 }
[01:29:28.291]                 else {
[01:29:28.291]                   if (TRUE) {
[01:29:28.291]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.291]                     {
[01:29:28.291]                       inherits <- base::inherits
[01:29:28.291]                       invokeRestart <- base::invokeRestart
[01:29:28.291]                       is.null <- base::is.null
[01:29:28.291]                       muffled <- FALSE
[01:29:28.291]                       if (inherits(cond, "message")) {
[01:29:28.291]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.291]                         if (muffled) 
[01:29:28.291]                           invokeRestart("muffleMessage")
[01:29:28.291]                       }
[01:29:28.291]                       else if (inherits(cond, "warning")) {
[01:29:28.291]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.291]                         if (muffled) 
[01:29:28.291]                           invokeRestart("muffleWarning")
[01:29:28.291]                       }
[01:29:28.291]                       else if (inherits(cond, "condition")) {
[01:29:28.291]                         if (!is.null(pattern)) {
[01:29:28.291]                           computeRestarts <- base::computeRestarts
[01:29:28.291]                           grepl <- base::grepl
[01:29:28.291]                           restarts <- computeRestarts(cond)
[01:29:28.291]                           for (restart in restarts) {
[01:29:28.291]                             name <- restart$name
[01:29:28.291]                             if (is.null(name)) 
[01:29:28.291]                               next
[01:29:28.291]                             if (!grepl(pattern, name)) 
[01:29:28.291]                               next
[01:29:28.291]                             invokeRestart(restart)
[01:29:28.291]                             muffled <- TRUE
[01:29:28.291]                             break
[01:29:28.291]                           }
[01:29:28.291]                         }
[01:29:28.291]                       }
[01:29:28.291]                       invisible(muffled)
[01:29:28.291]                     }
[01:29:28.291]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.291]                   }
[01:29:28.291]                 }
[01:29:28.291]             }
[01:29:28.291]         }))
[01:29:28.291]     }, error = function(ex) {
[01:29:28.291]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.291]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.291]                 ...future.rng), started = ...future.startTime, 
[01:29:28.291]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.291]             version = "1.8"), class = "FutureResult")
[01:29:28.291]     }, finally = {
[01:29:28.291]         if (!identical(...future.workdir, getwd())) 
[01:29:28.291]             setwd(...future.workdir)
[01:29:28.291]         {
[01:29:28.291]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.291]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.291]             }
[01:29:28.291]             base::options(...future.oldOptions)
[01:29:28.291]             if (.Platform$OS.type == "windows") {
[01:29:28.291]                 old_names <- names(...future.oldEnvVars)
[01:29:28.291]                 envs <- base::Sys.getenv()
[01:29:28.291]                 names <- names(envs)
[01:29:28.291]                 common <- intersect(names, old_names)
[01:29:28.291]                 added <- setdiff(names, old_names)
[01:29:28.291]                 removed <- setdiff(old_names, names)
[01:29:28.291]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.291]                   envs[common]]
[01:29:28.291]                 NAMES <- toupper(changed)
[01:29:28.291]                 args <- list()
[01:29:28.291]                 for (kk in seq_along(NAMES)) {
[01:29:28.291]                   name <- changed[[kk]]
[01:29:28.291]                   NAME <- NAMES[[kk]]
[01:29:28.291]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.291]                     next
[01:29:28.291]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.291]                 }
[01:29:28.291]                 NAMES <- toupper(added)
[01:29:28.291]                 for (kk in seq_along(NAMES)) {
[01:29:28.291]                   name <- added[[kk]]
[01:29:28.291]                   NAME <- NAMES[[kk]]
[01:29:28.291]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.291]                     next
[01:29:28.291]                   args[[name]] <- ""
[01:29:28.291]                 }
[01:29:28.291]                 NAMES <- toupper(removed)
[01:29:28.291]                 for (kk in seq_along(NAMES)) {
[01:29:28.291]                   name <- removed[[kk]]
[01:29:28.291]                   NAME <- NAMES[[kk]]
[01:29:28.291]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.291]                     next
[01:29:28.291]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.291]                 }
[01:29:28.291]                 if (length(args) > 0) 
[01:29:28.291]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.291]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.291]             }
[01:29:28.291]             else {
[01:29:28.291]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.291]             }
[01:29:28.291]             {
[01:29:28.291]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.291]                   0L) {
[01:29:28.291]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.291]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.291]                   base::options(opts)
[01:29:28.291]                 }
[01:29:28.291]                 {
[01:29:28.291]                   {
[01:29:28.291]                     base::assign(".Random.seed", c(10407L, -997816390L, 
[01:29:28.291]                     -1614775375L, 1388543034L, -889426559L, 1910868364L, 
[01:29:28.291]                     -2011626201L), envir = base::globalenv(), 
[01:29:28.291]                       inherits = FALSE)
[01:29:28.291]                     NULL
[01:29:28.291]                   }
[01:29:28.291]                   options(future.plan = NULL)
[01:29:28.291]                   if (is.na(NA_character_)) 
[01:29:28.291]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.291]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.291]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.291]                   {
[01:29:28.291]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.291]                     if (!future$lazy) 
[01:29:28.291]                       future <- run(future)
[01:29:28.291]                     invisible(future)
[01:29:28.291]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.291]                 }
[01:29:28.291]             }
[01:29:28.291]         }
[01:29:28.291]     })
[01:29:28.291]     if (TRUE) {
[01:29:28.291]         base::sink(type = "output", split = FALSE)
[01:29:28.291]         if (TRUE) {
[01:29:28.291]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.291]         }
[01:29:28.291]         else {
[01:29:28.291]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.291]         }
[01:29:28.291]         base::close(...future.stdout)
[01:29:28.291]         ...future.stdout <- NULL
[01:29:28.291]     }
[01:29:28.291]     ...future.result$conditions <- ...future.conditions
[01:29:28.291]     ...future.result$finished <- base::Sys.time()
[01:29:28.291]     ...future.result
[01:29:28.291] }
[01:29:28.295] assign_globals() ...
[01:29:28.295] List of 1
[01:29:28.295]  $ x: int [1:4] 0 1 2 3
[01:29:28.295]  - attr(*, "where")=List of 1
[01:29:28.295]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.295]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.295]  - attr(*, "resolved")= logi FALSE
[01:29:28.295]  - attr(*, "total_size")= num 64
[01:29:28.295]  - attr(*, "already-done")= logi TRUE
[01:29:28.298] - copied 'x' to environment
[01:29:28.298] assign_globals() ... done
[01:29:28.299] plan(): Setting new future strategy stack:
[01:29:28.299] List of future strategies:
[01:29:28.299] 1. sequential:
[01:29:28.299]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.299]    - tweaked: FALSE
[01:29:28.299]    - call: NULL
[01:29:28.299] plan(): nbrOfWorkers() = 1
[01:29:28.301] plan(): Setting new future strategy stack:
[01:29:28.301] List of future strategies:
[01:29:28.301] 1. sequential:
[01:29:28.301]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.301]    - tweaked: FALSE
[01:29:28.301]    - call: plan(strategy)
[01:29:28.301] plan(): nbrOfWorkers() = 1
[01:29:28.302] SequentialFuture started (and completed)
[01:29:28.302] - Launch lazy future ... done
[01:29:28.302] run() for 'SequentialFuture' ... done
[01:29:28.303] Future state: 'finished'
[01:29:28.303] signalConditions() ...
[01:29:28.303]  - include = 'condition'
[01:29:28.303]  - exclude = 'immediateCondition'
[01:29:28.303]  - resignal = TRUE
[01:29:28.303]  - Number of conditions: 1
[01:29:28.304]  - Condition #1: 'RngFutureWarning', 'FutureWarning', 'warning', 'RngFutureCondition', 'FutureCondition', 'condition'
[01:29:28.304] signalConditions() ... done
<RngFutureWarning: UNRELIABLE VALUE: Future ('fsample_1-682326') unexpectedly generated random numbers without specifying argument 'seed'. There is a risk that those random numbers are not statistically sound and the overall results might be invalid. To fix this, specify 'seed=TRUE'. This ensures that proper, parallel-safe random numbers are produced via the L'Ecuyer-CMRG method. To disable this check, use 'seed=NULL', or set option 'future.rng.onMisuse' to "ignore".>


Future UUID: ad2958b0-4fd4-a9b6-98f9-0a8f583dcf92


DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
SequentialFuture:
Label: 'fsample_1-682326'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96c893798
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Conditions captured: [n=1] 'RngFutureWarning'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'

DEBUG: END TROUBLESHOOTING HELP
[01:29:28.305] getGlobalsAndPackages() ...
[01:29:28.306] Searching for globals...
[01:29:28.307] - globals found: [3] '{', 'sample', 'x'
[01:29:28.307] Searching for globals ... DONE
[01:29:28.307] Resolving globals: FALSE
[01:29:28.308] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.308] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.308] - globals: [1] 'x'
[01:29:28.308] 
[01:29:28.309] getGlobalsAndPackages() ... DONE
[01:29:28.309] run() for 'Future' ...
[01:29:28.309] - state: 'created'
[01:29:28.309] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.310] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.310] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.310]   - Field: 'label'
[01:29:28.310]   - Field: 'local'
[01:29:28.310]   - Field: 'owner'
[01:29:28.310]   - Field: 'envir'
[01:29:28.311]   - Field: 'packages'
[01:29:28.311]   - Field: 'gc'
[01:29:28.311]   - Field: 'conditions'
[01:29:28.311]   - Field: 'expr'
[01:29:28.311]   - Field: 'uuid'
[01:29:28.312]   - Field: 'seed'
[01:29:28.312]   - Field: 'version'
[01:29:28.312]   - Field: 'result'
[01:29:28.312]   - Field: 'asynchronous'
[01:29:28.312]   - Field: 'calls'
[01:29:28.312]   - Field: 'globals'
[01:29:28.313]   - Field: 'stdout'
[01:29:28.313]   - Field: 'earlySignal'
[01:29:28.313]   - Field: 'lazy'
[01:29:28.313]   - Field: 'state'
[01:29:28.313] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.313] - Launch lazy future ...
[01:29:28.314] Packages needed by the future expression (n = 0): <none>
[01:29:28.314] Packages needed by future strategies (n = 0): <none>
[01:29:28.314] {
[01:29:28.314]     {
[01:29:28.314]         {
[01:29:28.314]             ...future.startTime <- base::Sys.time()
[01:29:28.314]             {
[01:29:28.314]                 {
[01:29:28.314]                   {
[01:29:28.314]                     base::local({
[01:29:28.314]                       has_future <- base::requireNamespace("future", 
[01:29:28.314]                         quietly = TRUE)
[01:29:28.314]                       if (has_future) {
[01:29:28.314]                         ns <- base::getNamespace("future")
[01:29:28.314]                         version <- ns[[".package"]][["version"]]
[01:29:28.314]                         if (is.null(version)) 
[01:29:28.314]                           version <- utils::packageVersion("future")
[01:29:28.314]                       }
[01:29:28.314]                       else {
[01:29:28.314]                         version <- NULL
[01:29:28.314]                       }
[01:29:28.314]                       if (!has_future || version < "1.8.0") {
[01:29:28.314]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.314]                           "", base::R.version$version.string), 
[01:29:28.314]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.314]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.314]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.314]                             "release", "version")], collapse = " "), 
[01:29:28.314]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.314]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.314]                           info)
[01:29:28.314]                         info <- base::paste(info, collapse = "; ")
[01:29:28.314]                         if (!has_future) {
[01:29:28.314]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.314]                             info)
[01:29:28.314]                         }
[01:29:28.314]                         else {
[01:29:28.314]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.314]                             info, version)
[01:29:28.314]                         }
[01:29:28.314]                         base::stop(msg)
[01:29:28.314]                       }
[01:29:28.314]                     })
[01:29:28.314]                   }
[01:29:28.314]                   options(future.plan = NULL)
[01:29:28.314]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.314]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.314]                 }
[01:29:28.314]                 ...future.workdir <- getwd()
[01:29:28.314]             }
[01:29:28.314]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.314]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.314]         }
[01:29:28.314]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.314]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.314]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.314]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.314]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.314]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.314]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.314]             base::names(...future.oldOptions))
[01:29:28.314]     }
[01:29:28.314]     if (FALSE) {
[01:29:28.314]     }
[01:29:28.314]     else {
[01:29:28.314]         if (TRUE) {
[01:29:28.314]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.314]                 open = "w")
[01:29:28.314]         }
[01:29:28.314]         else {
[01:29:28.314]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.314]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.314]         }
[01:29:28.314]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.314]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.314]             base::sink(type = "output", split = FALSE)
[01:29:28.314]             base::close(...future.stdout)
[01:29:28.314]         }, add = TRUE)
[01:29:28.314]     }
[01:29:28.314]     ...future.frame <- base::sys.nframe()
[01:29:28.314]     ...future.conditions <- base::list()
[01:29:28.314]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.314]     if (FALSE) {
[01:29:28.314]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.314]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.314]     }
[01:29:28.314]     ...future.result <- base::tryCatch({
[01:29:28.314]         base::withCallingHandlers({
[01:29:28.314]             ...future.value <- base::withVisible(base::local({
[01:29:28.314]                 sample(x, size = 1L)
[01:29:28.314]             }))
[01:29:28.314]             future::FutureResult(value = ...future.value$value, 
[01:29:28.314]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.314]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.314]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.314]                     ...future.globalenv.names))
[01:29:28.314]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.314]         }, condition = base::local({
[01:29:28.314]             c <- base::c
[01:29:28.314]             inherits <- base::inherits
[01:29:28.314]             invokeRestart <- base::invokeRestart
[01:29:28.314]             length <- base::length
[01:29:28.314]             list <- base::list
[01:29:28.314]             seq.int <- base::seq.int
[01:29:28.314]             signalCondition <- base::signalCondition
[01:29:28.314]             sys.calls <- base::sys.calls
[01:29:28.314]             `[[` <- base::`[[`
[01:29:28.314]             `+` <- base::`+`
[01:29:28.314]             `<<-` <- base::`<<-`
[01:29:28.314]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.314]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.314]                   3L)]
[01:29:28.314]             }
[01:29:28.314]             function(cond) {
[01:29:28.314]                 is_error <- inherits(cond, "error")
[01:29:28.314]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.314]                   NULL)
[01:29:28.314]                 if (is_error) {
[01:29:28.314]                   sessionInformation <- function() {
[01:29:28.314]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.314]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.314]                       search = base::search(), system = base::Sys.info())
[01:29:28.314]                   }
[01:29:28.314]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.314]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.314]                     cond$call), session = sessionInformation(), 
[01:29:28.314]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.314]                   signalCondition(cond)
[01:29:28.314]                 }
[01:29:28.314]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.314]                 "immediateCondition"))) {
[01:29:28.314]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.314]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.314]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.314]                   if (TRUE && !signal) {
[01:29:28.314]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.314]                     {
[01:29:28.314]                       inherits <- base::inherits
[01:29:28.314]                       invokeRestart <- base::invokeRestart
[01:29:28.314]                       is.null <- base::is.null
[01:29:28.314]                       muffled <- FALSE
[01:29:28.314]                       if (inherits(cond, "message")) {
[01:29:28.314]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.314]                         if (muffled) 
[01:29:28.314]                           invokeRestart("muffleMessage")
[01:29:28.314]                       }
[01:29:28.314]                       else if (inherits(cond, "warning")) {
[01:29:28.314]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.314]                         if (muffled) 
[01:29:28.314]                           invokeRestart("muffleWarning")
[01:29:28.314]                       }
[01:29:28.314]                       else if (inherits(cond, "condition")) {
[01:29:28.314]                         if (!is.null(pattern)) {
[01:29:28.314]                           computeRestarts <- base::computeRestarts
[01:29:28.314]                           grepl <- base::grepl
[01:29:28.314]                           restarts <- computeRestarts(cond)
[01:29:28.314]                           for (restart in restarts) {
[01:29:28.314]                             name <- restart$name
[01:29:28.314]                             if (is.null(name)) 
[01:29:28.314]                               next
[01:29:28.314]                             if (!grepl(pattern, name)) 
[01:29:28.314]                               next
[01:29:28.314]                             invokeRestart(restart)
[01:29:28.314]                             muffled <- TRUE
[01:29:28.314]                             break
[01:29:28.314]                           }
[01:29:28.314]                         }
[01:29:28.314]                       }
[01:29:28.314]                       invisible(muffled)
[01:29:28.314]                     }
[01:29:28.314]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.314]                   }
[01:29:28.314]                 }
[01:29:28.314]                 else {
[01:29:28.314]                   if (TRUE) {
[01:29:28.314]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.314]                     {
[01:29:28.314]                       inherits <- base::inherits
[01:29:28.314]                       invokeRestart <- base::invokeRestart
[01:29:28.314]                       is.null <- base::is.null
[01:29:28.314]                       muffled <- FALSE
[01:29:28.314]                       if (inherits(cond, "message")) {
[01:29:28.314]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.314]                         if (muffled) 
[01:29:28.314]                           invokeRestart("muffleMessage")
[01:29:28.314]                       }
[01:29:28.314]                       else if (inherits(cond, "warning")) {
[01:29:28.314]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.314]                         if (muffled) 
[01:29:28.314]                           invokeRestart("muffleWarning")
[01:29:28.314]                       }
[01:29:28.314]                       else if (inherits(cond, "condition")) {
[01:29:28.314]                         if (!is.null(pattern)) {
[01:29:28.314]                           computeRestarts <- base::computeRestarts
[01:29:28.314]                           grepl <- base::grepl
[01:29:28.314]                           restarts <- computeRestarts(cond)
[01:29:28.314]                           for (restart in restarts) {
[01:29:28.314]                             name <- restart$name
[01:29:28.314]                             if (is.null(name)) 
[01:29:28.314]                               next
[01:29:28.314]                             if (!grepl(pattern, name)) 
[01:29:28.314]                               next
[01:29:28.314]                             invokeRestart(restart)
[01:29:28.314]                             muffled <- TRUE
[01:29:28.314]                             break
[01:29:28.314]                           }
[01:29:28.314]                         }
[01:29:28.314]                       }
[01:29:28.314]                       invisible(muffled)
[01:29:28.314]                     }
[01:29:28.314]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.314]                   }
[01:29:28.314]                 }
[01:29:28.314]             }
[01:29:28.314]         }))
[01:29:28.314]     }, error = function(ex) {
[01:29:28.314]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.314]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.314]                 ...future.rng), started = ...future.startTime, 
[01:29:28.314]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.314]             version = "1.8"), class = "FutureResult")
[01:29:28.314]     }, finally = {
[01:29:28.314]         if (!identical(...future.workdir, getwd())) 
[01:29:28.314]             setwd(...future.workdir)
[01:29:28.314]         {
[01:29:28.314]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.314]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.314]             }
[01:29:28.314]             base::options(...future.oldOptions)
[01:29:28.314]             if (.Platform$OS.type == "windows") {
[01:29:28.314]                 old_names <- names(...future.oldEnvVars)
[01:29:28.314]                 envs <- base::Sys.getenv()
[01:29:28.314]                 names <- names(envs)
[01:29:28.314]                 common <- intersect(names, old_names)
[01:29:28.314]                 added <- setdiff(names, old_names)
[01:29:28.314]                 removed <- setdiff(old_names, names)
[01:29:28.314]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.314]                   envs[common]]
[01:29:28.314]                 NAMES <- toupper(changed)
[01:29:28.314]                 args <- list()
[01:29:28.314]                 for (kk in seq_along(NAMES)) {
[01:29:28.314]                   name <- changed[[kk]]
[01:29:28.314]                   NAME <- NAMES[[kk]]
[01:29:28.314]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.314]                     next
[01:29:28.314]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.314]                 }
[01:29:28.314]                 NAMES <- toupper(added)
[01:29:28.314]                 for (kk in seq_along(NAMES)) {
[01:29:28.314]                   name <- added[[kk]]
[01:29:28.314]                   NAME <- NAMES[[kk]]
[01:29:28.314]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.314]                     next
[01:29:28.314]                   args[[name]] <- ""
[01:29:28.314]                 }
[01:29:28.314]                 NAMES <- toupper(removed)
[01:29:28.314]                 for (kk in seq_along(NAMES)) {
[01:29:28.314]                   name <- removed[[kk]]
[01:29:28.314]                   NAME <- NAMES[[kk]]
[01:29:28.314]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.314]                     next
[01:29:28.314]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.314]                 }
[01:29:28.314]                 if (length(args) > 0) 
[01:29:28.314]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.314]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.314]             }
[01:29:28.314]             else {
[01:29:28.314]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.314]             }
[01:29:28.314]             {
[01:29:28.314]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.314]                   0L) {
[01:29:28.314]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.314]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.314]                   base::options(opts)
[01:29:28.314]                 }
[01:29:28.314]                 {
[01:29:28.314]                   {
[01:29:28.314]                     base::assign(".Random.seed", c(10407L, 239264608L, 
[01:29:28.314]                     -335112117L, 1547161855L, 1641764833L, 1205356201L, 
[01:29:28.314]                     12529069L), envir = base::globalenv(), inherits = FALSE)
[01:29:28.314]                     NULL
[01:29:28.314]                   }
[01:29:28.314]                   options(future.plan = NULL)
[01:29:28.314]                   if (is.na(NA_character_)) 
[01:29:28.314]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.314]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.314]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.314]                   {
[01:29:28.314]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.314]                     if (!future$lazy) 
[01:29:28.314]                       future <- run(future)
[01:29:28.314]                     invisible(future)
[01:29:28.314]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.314]                 }
[01:29:28.314]             }
[01:29:28.314]         }
[01:29:28.314]     })
[01:29:28.314]     if (TRUE) {
[01:29:28.314]         base::sink(type = "output", split = FALSE)
[01:29:28.314]         if (TRUE) {
[01:29:28.314]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.314]         }
[01:29:28.314]         else {
[01:29:28.314]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.314]         }
[01:29:28.314]         base::close(...future.stdout)
[01:29:28.314]         ...future.stdout <- NULL
[01:29:28.314]     }
[01:29:28.314]     ...future.result$conditions <- ...future.conditions
[01:29:28.314]     ...future.result$finished <- base::Sys.time()
[01:29:28.314]     ...future.result
[01:29:28.314] }
[01:29:28.318] assign_globals() ...
[01:29:28.318] List of 1
[01:29:28.318]  $ x: int [1:4] 0 1 2 3
[01:29:28.318]  - attr(*, "where")=List of 1
[01:29:28.318]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.318]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.318]  - attr(*, "resolved")= logi FALSE
[01:29:28.318]  - attr(*, "total_size")= num 64
[01:29:28.318]  - attr(*, "already-done")= logi TRUE
[01:29:28.323] - copied 'x' to environment
[01:29:28.323] assign_globals() ... done
[01:29:28.323] plan(): Setting new future strategy stack:
[01:29:28.324] List of future strategies:
[01:29:28.324] 1. sequential:
[01:29:28.324]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.324]    - tweaked: FALSE
[01:29:28.324]    - call: NULL
[01:29:28.324] plan(): nbrOfWorkers() = 1
[01:29:28.325] plan(): Setting new future strategy stack:
[01:29:28.325] List of future strategies:
[01:29:28.325] 1. sequential:
[01:29:28.325]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.325]    - tweaked: FALSE
[01:29:28.325]    - call: plan(strategy)
[01:29:28.326] plan(): nbrOfWorkers() = 1
[01:29:28.326] SequentialFuture started (and completed)
[01:29:28.327] - Launch lazy future ... done
[01:29:28.327] run() for 'SequentialFuture' ... done
[01:29:28.327] getGlobalsAndPackages() ...
[01:29:28.327] Searching for globals...
[01:29:28.329] - globals found: [3] '{', 'sample', 'x'
[01:29:28.329] Searching for globals ... DONE
[01:29:28.329] Resolving globals: FALSE
[01:29:28.329] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.330] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.330] - globals: [1] 'x'
[01:29:28.330] 
[01:29:28.330] getGlobalsAndPackages() ... DONE
[01:29:28.331] run() for 'Future' ...
[01:29:28.331] - state: 'created'
[01:29:28.331] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.332] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.332] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.332]   - Field: 'label'
[01:29:28.332]   - Field: 'local'
[01:29:28.332]   - Field: 'owner'
[01:29:28.332]   - Field: 'envir'
[01:29:28.333]   - Field: 'packages'
[01:29:28.333]   - Field: 'gc'
[01:29:28.333]   - Field: 'conditions'
[01:29:28.333]   - Field: 'expr'
[01:29:28.333]   - Field: 'uuid'
[01:29:28.333]   - Field: 'seed'
[01:29:28.334]   - Field: 'version'
[01:29:28.334]   - Field: 'result'
[01:29:28.334]   - Field: 'asynchronous'
[01:29:28.334]   - Field: 'calls'
[01:29:28.334]   - Field: 'globals'
[01:29:28.335]   - Field: 'stdout'
[01:29:28.335]   - Field: 'earlySignal'
[01:29:28.335]   - Field: 'lazy'
[01:29:28.335]   - Field: 'state'
[01:29:28.335] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.335] - Launch lazy future ...
[01:29:28.336] Packages needed by the future expression (n = 0): <none>
[01:29:28.336] Packages needed by future strategies (n = 0): <none>
[01:29:28.336] {
[01:29:28.336]     {
[01:29:28.336]         {
[01:29:28.336]             ...future.startTime <- base::Sys.time()
[01:29:28.336]             {
[01:29:28.336]                 {
[01:29:28.336]                   {
[01:29:28.336]                     base::local({
[01:29:28.336]                       has_future <- base::requireNamespace("future", 
[01:29:28.336]                         quietly = TRUE)
[01:29:28.336]                       if (has_future) {
[01:29:28.336]                         ns <- base::getNamespace("future")
[01:29:28.336]                         version <- ns[[".package"]][["version"]]
[01:29:28.336]                         if (is.null(version)) 
[01:29:28.336]                           version <- utils::packageVersion("future")
[01:29:28.336]                       }
[01:29:28.336]                       else {
[01:29:28.336]                         version <- NULL
[01:29:28.336]                       }
[01:29:28.336]                       if (!has_future || version < "1.8.0") {
[01:29:28.336]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.336]                           "", base::R.version$version.string), 
[01:29:28.336]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.336]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.336]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.336]                             "release", "version")], collapse = " "), 
[01:29:28.336]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.336]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.336]                           info)
[01:29:28.336]                         info <- base::paste(info, collapse = "; ")
[01:29:28.336]                         if (!has_future) {
[01:29:28.336]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.336]                             info)
[01:29:28.336]                         }
[01:29:28.336]                         else {
[01:29:28.336]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.336]                             info, version)
[01:29:28.336]                         }
[01:29:28.336]                         base::stop(msg)
[01:29:28.336]                       }
[01:29:28.336]                     })
[01:29:28.336]                   }
[01:29:28.336]                   options(future.plan = NULL)
[01:29:28.336]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.336]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.336]                 }
[01:29:28.336]                 ...future.workdir <- getwd()
[01:29:28.336]             }
[01:29:28.336]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.336]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.336]         }
[01:29:28.336]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.336]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.336]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.336]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.336]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.336]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.336]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.336]             base::names(...future.oldOptions))
[01:29:28.336]     }
[01:29:28.336]     if (FALSE) {
[01:29:28.336]     }
[01:29:28.336]     else {
[01:29:28.336]         if (TRUE) {
[01:29:28.336]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.336]                 open = "w")
[01:29:28.336]         }
[01:29:28.336]         else {
[01:29:28.336]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.336]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.336]         }
[01:29:28.336]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.336]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.336]             base::sink(type = "output", split = FALSE)
[01:29:28.336]             base::close(...future.stdout)
[01:29:28.336]         }, add = TRUE)
[01:29:28.336]     }
[01:29:28.336]     ...future.frame <- base::sys.nframe()
[01:29:28.336]     ...future.conditions <- base::list()
[01:29:28.336]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.336]     if (FALSE) {
[01:29:28.336]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.336]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.336]     }
[01:29:28.336]     ...future.result <- base::tryCatch({
[01:29:28.336]         base::withCallingHandlers({
[01:29:28.336]             ...future.value <- base::withVisible(base::local({
[01:29:28.336]                 sample(x, size = 1L)
[01:29:28.336]             }))
[01:29:28.336]             future::FutureResult(value = ...future.value$value, 
[01:29:28.336]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.336]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.336]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.336]                     ...future.globalenv.names))
[01:29:28.336]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.336]         }, condition = base::local({
[01:29:28.336]             c <- base::c
[01:29:28.336]             inherits <- base::inherits
[01:29:28.336]             invokeRestart <- base::invokeRestart
[01:29:28.336]             length <- base::length
[01:29:28.336]             list <- base::list
[01:29:28.336]             seq.int <- base::seq.int
[01:29:28.336]             signalCondition <- base::signalCondition
[01:29:28.336]             sys.calls <- base::sys.calls
[01:29:28.336]             `[[` <- base::`[[`
[01:29:28.336]             `+` <- base::`+`
[01:29:28.336]             `<<-` <- base::`<<-`
[01:29:28.336]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.336]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.336]                   3L)]
[01:29:28.336]             }
[01:29:28.336]             function(cond) {
[01:29:28.336]                 is_error <- inherits(cond, "error")
[01:29:28.336]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.336]                   NULL)
[01:29:28.336]                 if (is_error) {
[01:29:28.336]                   sessionInformation <- function() {
[01:29:28.336]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.336]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.336]                       search = base::search(), system = base::Sys.info())
[01:29:28.336]                   }
[01:29:28.336]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.336]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.336]                     cond$call), session = sessionInformation(), 
[01:29:28.336]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.336]                   signalCondition(cond)
[01:29:28.336]                 }
[01:29:28.336]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.336]                 "immediateCondition"))) {
[01:29:28.336]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.336]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.336]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.336]                   if (TRUE && !signal) {
[01:29:28.336]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.336]                     {
[01:29:28.336]                       inherits <- base::inherits
[01:29:28.336]                       invokeRestart <- base::invokeRestart
[01:29:28.336]                       is.null <- base::is.null
[01:29:28.336]                       muffled <- FALSE
[01:29:28.336]                       if (inherits(cond, "message")) {
[01:29:28.336]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.336]                         if (muffled) 
[01:29:28.336]                           invokeRestart("muffleMessage")
[01:29:28.336]                       }
[01:29:28.336]                       else if (inherits(cond, "warning")) {
[01:29:28.336]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.336]                         if (muffled) 
[01:29:28.336]                           invokeRestart("muffleWarning")
[01:29:28.336]                       }
[01:29:28.336]                       else if (inherits(cond, "condition")) {
[01:29:28.336]                         if (!is.null(pattern)) {
[01:29:28.336]                           computeRestarts <- base::computeRestarts
[01:29:28.336]                           grepl <- base::grepl
[01:29:28.336]                           restarts <- computeRestarts(cond)
[01:29:28.336]                           for (restart in restarts) {
[01:29:28.336]                             name <- restart$name
[01:29:28.336]                             if (is.null(name)) 
[01:29:28.336]                               next
[01:29:28.336]                             if (!grepl(pattern, name)) 
[01:29:28.336]                               next
[01:29:28.336]                             invokeRestart(restart)
[01:29:28.336]                             muffled <- TRUE
[01:29:28.336]                             break
[01:29:28.336]                           }
[01:29:28.336]                         }
[01:29:28.336]                       }
[01:29:28.336]                       invisible(muffled)
[01:29:28.336]                     }
[01:29:28.336]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.336]                   }
[01:29:28.336]                 }
[01:29:28.336]                 else {
[01:29:28.336]                   if (TRUE) {
[01:29:28.336]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.336]                     {
[01:29:28.336]                       inherits <- base::inherits
[01:29:28.336]                       invokeRestart <- base::invokeRestart
[01:29:28.336]                       is.null <- base::is.null
[01:29:28.336]                       muffled <- FALSE
[01:29:28.336]                       if (inherits(cond, "message")) {
[01:29:28.336]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.336]                         if (muffled) 
[01:29:28.336]                           invokeRestart("muffleMessage")
[01:29:28.336]                       }
[01:29:28.336]                       else if (inherits(cond, "warning")) {
[01:29:28.336]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.336]                         if (muffled) 
[01:29:28.336]                           invokeRestart("muffleWarning")
[01:29:28.336]                       }
[01:29:28.336]                       else if (inherits(cond, "condition")) {
[01:29:28.336]                         if (!is.null(pattern)) {
[01:29:28.336]                           computeRestarts <- base::computeRestarts
[01:29:28.336]                           grepl <- base::grepl
[01:29:28.336]                           restarts <- computeRestarts(cond)
[01:29:28.336]                           for (restart in restarts) {
[01:29:28.336]                             name <- restart$name
[01:29:28.336]                             if (is.null(name)) 
[01:29:28.336]                               next
[01:29:28.336]                             if (!grepl(pattern, name)) 
[01:29:28.336]                               next
[01:29:28.336]                             invokeRestart(restart)
[01:29:28.336]                             muffled <- TRUE
[01:29:28.336]                             break
[01:29:28.336]                           }
[01:29:28.336]                         }
[01:29:28.336]                       }
[01:29:28.336]                       invisible(muffled)
[01:29:28.336]                     }
[01:29:28.336]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.336]                   }
[01:29:28.336]                 }
[01:29:28.336]             }
[01:29:28.336]         }))
[01:29:28.336]     }, error = function(ex) {
[01:29:28.336]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.336]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.336]                 ...future.rng), started = ...future.startTime, 
[01:29:28.336]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.336]             version = "1.8"), class = "FutureResult")
[01:29:28.336]     }, finally = {
[01:29:28.336]         if (!identical(...future.workdir, getwd())) 
[01:29:28.336]             setwd(...future.workdir)
[01:29:28.336]         {
[01:29:28.336]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.336]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.336]             }
[01:29:28.336]             base::options(...future.oldOptions)
[01:29:28.336]             if (.Platform$OS.type == "windows") {
[01:29:28.336]                 old_names <- names(...future.oldEnvVars)
[01:29:28.336]                 envs <- base::Sys.getenv()
[01:29:28.336]                 names <- names(envs)
[01:29:28.336]                 common <- intersect(names, old_names)
[01:29:28.336]                 added <- setdiff(names, old_names)
[01:29:28.336]                 removed <- setdiff(old_names, names)
[01:29:28.336]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.336]                   envs[common]]
[01:29:28.336]                 NAMES <- toupper(changed)
[01:29:28.336]                 args <- list()
[01:29:28.336]                 for (kk in seq_along(NAMES)) {
[01:29:28.336]                   name <- changed[[kk]]
[01:29:28.336]                   NAME <- NAMES[[kk]]
[01:29:28.336]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.336]                     next
[01:29:28.336]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.336]                 }
[01:29:28.336]                 NAMES <- toupper(added)
[01:29:28.336]                 for (kk in seq_along(NAMES)) {
[01:29:28.336]                   name <- added[[kk]]
[01:29:28.336]                   NAME <- NAMES[[kk]]
[01:29:28.336]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.336]                     next
[01:29:28.336]                   args[[name]] <- ""
[01:29:28.336]                 }
[01:29:28.336]                 NAMES <- toupper(removed)
[01:29:28.336]                 for (kk in seq_along(NAMES)) {
[01:29:28.336]                   name <- removed[[kk]]
[01:29:28.336]                   NAME <- NAMES[[kk]]
[01:29:28.336]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.336]                     next
[01:29:28.336]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.336]                 }
[01:29:28.336]                 if (length(args) > 0) 
[01:29:28.336]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.336]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.336]             }
[01:29:28.336]             else {
[01:29:28.336]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.336]             }
[01:29:28.336]             {
[01:29:28.336]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.336]                   0L) {
[01:29:28.336]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.336]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.336]                   base::options(opts)
[01:29:28.336]                 }
[01:29:28.336]                 {
[01:29:28.336]                   {
[01:29:28.336]                     base::assign(".Random.seed", c(10407L, 1547161855L, 
[01:29:28.336]                     2030137722L, -2113589453L, 12529069L, 1564813159L, 
[01:29:28.336]                     -540026874L), envir = base::globalenv(), 
[01:29:28.336]                       inherits = FALSE)
[01:29:28.336]                     NULL
[01:29:28.336]                   }
[01:29:28.336]                   options(future.plan = NULL)
[01:29:28.336]                   if (is.na(NA_character_)) 
[01:29:28.336]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.336]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.336]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.336]                   {
[01:29:28.336]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.336]                     if (!future$lazy) 
[01:29:28.336]                       future <- run(future)
[01:29:28.336]                     invisible(future)
[01:29:28.336]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.336]                 }
[01:29:28.336]             }
[01:29:28.336]         }
[01:29:28.336]     })
[01:29:28.336]     if (TRUE) {
[01:29:28.336]         base::sink(type = "output", split = FALSE)
[01:29:28.336]         if (TRUE) {
[01:29:28.336]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.336]         }
[01:29:28.336]         else {
[01:29:28.336]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.336]         }
[01:29:28.336]         base::close(...future.stdout)
[01:29:28.336]         ...future.stdout <- NULL
[01:29:28.336]     }
[01:29:28.336]     ...future.result$conditions <- ...future.conditions
[01:29:28.336]     ...future.result$finished <- base::Sys.time()
[01:29:28.336]     ...future.result
[01:29:28.336] }
[01:29:28.340] assign_globals() ...
[01:29:28.340] List of 1
[01:29:28.340]  $ x: int [1:4] 0 1 2 3
[01:29:28.340]  - attr(*, "where")=List of 1
[01:29:28.340]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.340]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.340]  - attr(*, "resolved")= logi FALSE
[01:29:28.340]  - attr(*, "total_size")= num 64
[01:29:28.340]  - attr(*, "already-done")= logi TRUE
[01:29:28.343] - copied 'x' to environment
[01:29:28.343] assign_globals() ... done
[01:29:28.344] plan(): Setting new future strategy stack:
[01:29:28.344] List of future strategies:
[01:29:28.344] 1. sequential:
[01:29:28.344]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.344]    - tweaked: FALSE
[01:29:28.344]    - call: NULL
[01:29:28.344] plan(): nbrOfWorkers() = 1
[01:29:28.346] plan(): Setting new future strategy stack:
[01:29:28.346] List of future strategies:
[01:29:28.346] 1. sequential:
[01:29:28.346]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.346]    - tweaked: FALSE
[01:29:28.346]    - call: plan(strategy)
[01:29:28.346] plan(): nbrOfWorkers() = 1
[01:29:28.347] SequentialFuture started (and completed)
[01:29:28.347] - Launch lazy future ... done
[01:29:28.347] run() for 'SequentialFuture' ... done
[01:29:28.348] getGlobalsAndPackages() ...
[01:29:28.348] Searching for globals...
[01:29:28.349] - globals found: [3] '{', 'sample', 'x'
[01:29:28.349] Searching for globals ... DONE
[01:29:28.349] Resolving globals: FALSE
[01:29:28.350] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.350] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.352] - globals: [1] 'x'
[01:29:28.352] 
[01:29:28.352] getGlobalsAndPackages() ... DONE
[01:29:28.352] run() for 'Future' ...
[01:29:28.352] - state: 'created'
[01:29:28.353] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.353] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.353] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.353]   - Field: 'label'
[01:29:28.354]   - Field: 'local'
[01:29:28.354]   - Field: 'owner'
[01:29:28.354]   - Field: 'envir'
[01:29:28.354]   - Field: 'packages'
[01:29:28.354]   - Field: 'gc'
[01:29:28.355]   - Field: 'conditions'
[01:29:28.355]   - Field: 'expr'
[01:29:28.355]   - Field: 'uuid'
[01:29:28.355]   - Field: 'seed'
[01:29:28.355]   - Field: 'version'
[01:29:28.355]   - Field: 'result'
[01:29:28.356]   - Field: 'asynchronous'
[01:29:28.356]   - Field: 'calls'
[01:29:28.356]   - Field: 'globals'
[01:29:28.356]   - Field: 'stdout'
[01:29:28.356]   - Field: 'earlySignal'
[01:29:28.356]   - Field: 'lazy'
[01:29:28.357]   - Field: 'state'
[01:29:28.357] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.357] - Launch lazy future ...
[01:29:28.357] Packages needed by the future expression (n = 0): <none>
[01:29:28.357] Packages needed by future strategies (n = 0): <none>
[01:29:28.358] {
[01:29:28.358]     {
[01:29:28.358]         {
[01:29:28.358]             ...future.startTime <- base::Sys.time()
[01:29:28.358]             {
[01:29:28.358]                 {
[01:29:28.358]                   {
[01:29:28.358]                     base::local({
[01:29:28.358]                       has_future <- base::requireNamespace("future", 
[01:29:28.358]                         quietly = TRUE)
[01:29:28.358]                       if (has_future) {
[01:29:28.358]                         ns <- base::getNamespace("future")
[01:29:28.358]                         version <- ns[[".package"]][["version"]]
[01:29:28.358]                         if (is.null(version)) 
[01:29:28.358]                           version <- utils::packageVersion("future")
[01:29:28.358]                       }
[01:29:28.358]                       else {
[01:29:28.358]                         version <- NULL
[01:29:28.358]                       }
[01:29:28.358]                       if (!has_future || version < "1.8.0") {
[01:29:28.358]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.358]                           "", base::R.version$version.string), 
[01:29:28.358]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.358]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.358]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.358]                             "release", "version")], collapse = " "), 
[01:29:28.358]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.358]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.358]                           info)
[01:29:28.358]                         info <- base::paste(info, collapse = "; ")
[01:29:28.358]                         if (!has_future) {
[01:29:28.358]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.358]                             info)
[01:29:28.358]                         }
[01:29:28.358]                         else {
[01:29:28.358]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.358]                             info, version)
[01:29:28.358]                         }
[01:29:28.358]                         base::stop(msg)
[01:29:28.358]                       }
[01:29:28.358]                     })
[01:29:28.358]                   }
[01:29:28.358]                   options(future.plan = NULL)
[01:29:28.358]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.358]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.358]                 }
[01:29:28.358]                 ...future.workdir <- getwd()
[01:29:28.358]             }
[01:29:28.358]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.358]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.358]         }
[01:29:28.358]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.358]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.358]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.358]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.358]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.358]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.358]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.358]             base::names(...future.oldOptions))
[01:29:28.358]     }
[01:29:28.358]     if (FALSE) {
[01:29:28.358]     }
[01:29:28.358]     else {
[01:29:28.358]         if (TRUE) {
[01:29:28.358]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.358]                 open = "w")
[01:29:28.358]         }
[01:29:28.358]         else {
[01:29:28.358]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.358]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.358]         }
[01:29:28.358]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.358]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.358]             base::sink(type = "output", split = FALSE)
[01:29:28.358]             base::close(...future.stdout)
[01:29:28.358]         }, add = TRUE)
[01:29:28.358]     }
[01:29:28.358]     ...future.frame <- base::sys.nframe()
[01:29:28.358]     ...future.conditions <- base::list()
[01:29:28.358]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.358]     if (FALSE) {
[01:29:28.358]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.358]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.358]     }
[01:29:28.358]     ...future.result <- base::tryCatch({
[01:29:28.358]         base::withCallingHandlers({
[01:29:28.358]             ...future.value <- base::withVisible(base::local({
[01:29:28.358]                 sample(x, size = 1L)
[01:29:28.358]             }))
[01:29:28.358]             future::FutureResult(value = ...future.value$value, 
[01:29:28.358]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.358]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.358]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.358]                     ...future.globalenv.names))
[01:29:28.358]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.358]         }, condition = base::local({
[01:29:28.358]             c <- base::c
[01:29:28.358]             inherits <- base::inherits
[01:29:28.358]             invokeRestart <- base::invokeRestart
[01:29:28.358]             length <- base::length
[01:29:28.358]             list <- base::list
[01:29:28.358]             seq.int <- base::seq.int
[01:29:28.358]             signalCondition <- base::signalCondition
[01:29:28.358]             sys.calls <- base::sys.calls
[01:29:28.358]             `[[` <- base::`[[`
[01:29:28.358]             `+` <- base::`+`
[01:29:28.358]             `<<-` <- base::`<<-`
[01:29:28.358]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.358]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.358]                   3L)]
[01:29:28.358]             }
[01:29:28.358]             function(cond) {
[01:29:28.358]                 is_error <- inherits(cond, "error")
[01:29:28.358]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.358]                   NULL)
[01:29:28.358]                 if (is_error) {
[01:29:28.358]                   sessionInformation <- function() {
[01:29:28.358]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.358]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.358]                       search = base::search(), system = base::Sys.info())
[01:29:28.358]                   }
[01:29:28.358]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.358]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.358]                     cond$call), session = sessionInformation(), 
[01:29:28.358]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.358]                   signalCondition(cond)
[01:29:28.358]                 }
[01:29:28.358]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.358]                 "immediateCondition"))) {
[01:29:28.358]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.358]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.358]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.358]                   if (TRUE && !signal) {
[01:29:28.358]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.358]                     {
[01:29:28.358]                       inherits <- base::inherits
[01:29:28.358]                       invokeRestart <- base::invokeRestart
[01:29:28.358]                       is.null <- base::is.null
[01:29:28.358]                       muffled <- FALSE
[01:29:28.358]                       if (inherits(cond, "message")) {
[01:29:28.358]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.358]                         if (muffled) 
[01:29:28.358]                           invokeRestart("muffleMessage")
[01:29:28.358]                       }
[01:29:28.358]                       else if (inherits(cond, "warning")) {
[01:29:28.358]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.358]                         if (muffled) 
[01:29:28.358]                           invokeRestart("muffleWarning")
[01:29:28.358]                       }
[01:29:28.358]                       else if (inherits(cond, "condition")) {
[01:29:28.358]                         if (!is.null(pattern)) {
[01:29:28.358]                           computeRestarts <- base::computeRestarts
[01:29:28.358]                           grepl <- base::grepl
[01:29:28.358]                           restarts <- computeRestarts(cond)
[01:29:28.358]                           for (restart in restarts) {
[01:29:28.358]                             name <- restart$name
[01:29:28.358]                             if (is.null(name)) 
[01:29:28.358]                               next
[01:29:28.358]                             if (!grepl(pattern, name)) 
[01:29:28.358]                               next
[01:29:28.358]                             invokeRestart(restart)
[01:29:28.358]                             muffled <- TRUE
[01:29:28.358]                             break
[01:29:28.358]                           }
[01:29:28.358]                         }
[01:29:28.358]                       }
[01:29:28.358]                       invisible(muffled)
[01:29:28.358]                     }
[01:29:28.358]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.358]                   }
[01:29:28.358]                 }
[01:29:28.358]                 else {
[01:29:28.358]                   if (TRUE) {
[01:29:28.358]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.358]                     {
[01:29:28.358]                       inherits <- base::inherits
[01:29:28.358]                       invokeRestart <- base::invokeRestart
[01:29:28.358]                       is.null <- base::is.null
[01:29:28.358]                       muffled <- FALSE
[01:29:28.358]                       if (inherits(cond, "message")) {
[01:29:28.358]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.358]                         if (muffled) 
[01:29:28.358]                           invokeRestart("muffleMessage")
[01:29:28.358]                       }
[01:29:28.358]                       else if (inherits(cond, "warning")) {
[01:29:28.358]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.358]                         if (muffled) 
[01:29:28.358]                           invokeRestart("muffleWarning")
[01:29:28.358]                       }
[01:29:28.358]                       else if (inherits(cond, "condition")) {
[01:29:28.358]                         if (!is.null(pattern)) {
[01:29:28.358]                           computeRestarts <- base::computeRestarts
[01:29:28.358]                           grepl <- base::grepl
[01:29:28.358]                           restarts <- computeRestarts(cond)
[01:29:28.358]                           for (restart in restarts) {
[01:29:28.358]                             name <- restart$name
[01:29:28.358]                             if (is.null(name)) 
[01:29:28.358]                               next
[01:29:28.358]                             if (!grepl(pattern, name)) 
[01:29:28.358]                               next
[01:29:28.358]                             invokeRestart(restart)
[01:29:28.358]                             muffled <- TRUE
[01:29:28.358]                             break
[01:29:28.358]                           }
[01:29:28.358]                         }
[01:29:28.358]                       }
[01:29:28.358]                       invisible(muffled)
[01:29:28.358]                     }
[01:29:28.358]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.358]                   }
[01:29:28.358]                 }
[01:29:28.358]             }
[01:29:28.358]         }))
[01:29:28.358]     }, error = function(ex) {
[01:29:28.358]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.358]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.358]                 ...future.rng), started = ...future.startTime, 
[01:29:28.358]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.358]             version = "1.8"), class = "FutureResult")
[01:29:28.358]     }, finally = {
[01:29:28.358]         if (!identical(...future.workdir, getwd())) 
[01:29:28.358]             setwd(...future.workdir)
[01:29:28.358]         {
[01:29:28.358]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.358]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.358]             }
[01:29:28.358]             base::options(...future.oldOptions)
[01:29:28.358]             if (.Platform$OS.type == "windows") {
[01:29:28.358]                 old_names <- names(...future.oldEnvVars)
[01:29:28.358]                 envs <- base::Sys.getenv()
[01:29:28.358]                 names <- names(envs)
[01:29:28.358]                 common <- intersect(names, old_names)
[01:29:28.358]                 added <- setdiff(names, old_names)
[01:29:28.358]                 removed <- setdiff(old_names, names)
[01:29:28.358]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.358]                   envs[common]]
[01:29:28.358]                 NAMES <- toupper(changed)
[01:29:28.358]                 args <- list()
[01:29:28.358]                 for (kk in seq_along(NAMES)) {
[01:29:28.358]                   name <- changed[[kk]]
[01:29:28.358]                   NAME <- NAMES[[kk]]
[01:29:28.358]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.358]                     next
[01:29:28.358]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.358]                 }
[01:29:28.358]                 NAMES <- toupper(added)
[01:29:28.358]                 for (kk in seq_along(NAMES)) {
[01:29:28.358]                   name <- added[[kk]]
[01:29:28.358]                   NAME <- NAMES[[kk]]
[01:29:28.358]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.358]                     next
[01:29:28.358]                   args[[name]] <- ""
[01:29:28.358]                 }
[01:29:28.358]                 NAMES <- toupper(removed)
[01:29:28.358]                 for (kk in seq_along(NAMES)) {
[01:29:28.358]                   name <- removed[[kk]]
[01:29:28.358]                   NAME <- NAMES[[kk]]
[01:29:28.358]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.358]                     next
[01:29:28.358]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.358]                 }
[01:29:28.358]                 if (length(args) > 0) 
[01:29:28.358]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.358]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.358]             }
[01:29:28.358]             else {
[01:29:28.358]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.358]             }
[01:29:28.358]             {
[01:29:28.358]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.358]                   0L) {
[01:29:28.358]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.358]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.358]                   base::options(opts)
[01:29:28.358]                 }
[01:29:28.358]                 {
[01:29:28.358]                   {
[01:29:28.358]                     base::assign(".Random.seed", c(10407L, -2113589453L, 
[01:29:28.358]                     -328779341L, 32665513L, -540026874L, 111718912L, 
[01:29:28.358]                     -414573498L), envir = base::globalenv(), 
[01:29:28.358]                       inherits = FALSE)
[01:29:28.358]                     NULL
[01:29:28.358]                   }
[01:29:28.358]                   options(future.plan = NULL)
[01:29:28.358]                   if (is.na(NA_character_)) 
[01:29:28.358]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.358]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.358]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.358]                   {
[01:29:28.358]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.358]                     if (!future$lazy) 
[01:29:28.358]                       future <- run(future)
[01:29:28.358]                     invisible(future)
[01:29:28.358]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.358]                 }
[01:29:28.358]             }
[01:29:28.358]         }
[01:29:28.358]     })
[01:29:28.358]     if (TRUE) {
[01:29:28.358]         base::sink(type = "output", split = FALSE)
[01:29:28.358]         if (TRUE) {
[01:29:28.358]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.358]         }
[01:29:28.358]         else {
[01:29:28.358]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.358]         }
[01:29:28.358]         base::close(...future.stdout)
[01:29:28.358]         ...future.stdout <- NULL
[01:29:28.358]     }
[01:29:28.358]     ...future.result$conditions <- ...future.conditions
[01:29:28.358]     ...future.result$finished <- base::Sys.time()
[01:29:28.358]     ...future.result
[01:29:28.358] }
[01:29:28.362] assign_globals() ...
[01:29:28.362] List of 1
[01:29:28.362]  $ x: int [1:4] 0 1 2 3
[01:29:28.362]  - attr(*, "where")=List of 1
[01:29:28.362]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.362]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.362]  - attr(*, "resolved")= logi FALSE
[01:29:28.362]  - attr(*, "total_size")= num 64
[01:29:28.362]  - attr(*, "already-done")= logi TRUE
[01:29:28.365] - copied 'x' to environment
[01:29:28.365] assign_globals() ... done
[01:29:28.365] plan(): Setting new future strategy stack:
[01:29:28.366] List of future strategies:
[01:29:28.366] 1. sequential:
[01:29:28.366]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.366]    - tweaked: FALSE
[01:29:28.366]    - call: NULL
[01:29:28.366] plan(): nbrOfWorkers() = 1
[01:29:28.367] plan(): Setting new future strategy stack:
[01:29:28.368] List of future strategies:
[01:29:28.368] 1. sequential:
[01:29:28.368]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.368]    - tweaked: FALSE
[01:29:28.368]    - call: plan(strategy)
[01:29:28.368] plan(): nbrOfWorkers() = 1
[01:29:28.368] SequentialFuture started (and completed)
[01:29:28.369] - Launch lazy future ... done
[01:29:28.369] run() for 'SequentialFuture' ... done
[01:29:28.369] getGlobalsAndPackages() ...
[01:29:28.370] Searching for globals...
[01:29:28.371] - globals found: [3] '{', 'sample', 'x'
[01:29:28.371] Searching for globals ... DONE
[01:29:28.371] Resolving globals: FALSE
[01:29:28.372] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.372] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.372] - globals: [1] 'x'
[01:29:28.372] 
[01:29:28.373] getGlobalsAndPackages() ... DONE
[01:29:28.373] run() for 'Future' ...
[01:29:28.373] - state: 'created'
[01:29:28.373] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.374] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.374] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.374]   - Field: 'label'
[01:29:28.374]   - Field: 'local'
[01:29:28.374]   - Field: 'owner'
[01:29:28.375]   - Field: 'envir'
[01:29:28.375]   - Field: 'packages'
[01:29:28.375]   - Field: 'gc'
[01:29:28.375]   - Field: 'conditions'
[01:29:28.375]   - Field: 'expr'
[01:29:28.376]   - Field: 'uuid'
[01:29:28.376]   - Field: 'seed'
[01:29:28.376]   - Field: 'version'
[01:29:28.376]   - Field: 'result'
[01:29:28.376]   - Field: 'asynchronous'
[01:29:28.376]   - Field: 'calls'
[01:29:28.377]   - Field: 'globals'
[01:29:28.377]   - Field: 'stdout'
[01:29:28.377]   - Field: 'earlySignal'
[01:29:28.377]   - Field: 'lazy'
[01:29:28.377]   - Field: 'state'
[01:29:28.378] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.378] - Launch lazy future ...
[01:29:28.378] Packages needed by the future expression (n = 0): <none>
[01:29:28.378] Packages needed by future strategies (n = 0): <none>
[01:29:28.379] {
[01:29:28.379]     {
[01:29:28.379]         {
[01:29:28.379]             ...future.startTime <- base::Sys.time()
[01:29:28.379]             {
[01:29:28.379]                 {
[01:29:28.379]                   {
[01:29:28.379]                     base::local({
[01:29:28.379]                       has_future <- base::requireNamespace("future", 
[01:29:28.379]                         quietly = TRUE)
[01:29:28.379]                       if (has_future) {
[01:29:28.379]                         ns <- base::getNamespace("future")
[01:29:28.379]                         version <- ns[[".package"]][["version"]]
[01:29:28.379]                         if (is.null(version)) 
[01:29:28.379]                           version <- utils::packageVersion("future")
[01:29:28.379]                       }
[01:29:28.379]                       else {
[01:29:28.379]                         version <- NULL
[01:29:28.379]                       }
[01:29:28.379]                       if (!has_future || version < "1.8.0") {
[01:29:28.379]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.379]                           "", base::R.version$version.string), 
[01:29:28.379]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.379]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.379]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.379]                             "release", "version")], collapse = " "), 
[01:29:28.379]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.379]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.379]                           info)
[01:29:28.379]                         info <- base::paste(info, collapse = "; ")
[01:29:28.379]                         if (!has_future) {
[01:29:28.379]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.379]                             info)
[01:29:28.379]                         }
[01:29:28.379]                         else {
[01:29:28.379]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.379]                             info, version)
[01:29:28.379]                         }
[01:29:28.379]                         base::stop(msg)
[01:29:28.379]                       }
[01:29:28.379]                     })
[01:29:28.379]                   }
[01:29:28.379]                   options(future.plan = NULL)
[01:29:28.379]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.379]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.379]                 }
[01:29:28.379]                 ...future.workdir <- getwd()
[01:29:28.379]             }
[01:29:28.379]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.379]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.379]         }
[01:29:28.379]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.379]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.379]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.379]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.379]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.379]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.379]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.379]             base::names(...future.oldOptions))
[01:29:28.379]     }
[01:29:28.379]     if (FALSE) {
[01:29:28.379]     }
[01:29:28.379]     else {
[01:29:28.379]         if (TRUE) {
[01:29:28.379]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.379]                 open = "w")
[01:29:28.379]         }
[01:29:28.379]         else {
[01:29:28.379]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.379]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.379]         }
[01:29:28.379]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.379]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.379]             base::sink(type = "output", split = FALSE)
[01:29:28.379]             base::close(...future.stdout)
[01:29:28.379]         }, add = TRUE)
[01:29:28.379]     }
[01:29:28.379]     ...future.frame <- base::sys.nframe()
[01:29:28.379]     ...future.conditions <- base::list()
[01:29:28.379]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.379]     if (FALSE) {
[01:29:28.379]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.379]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.379]     }
[01:29:28.379]     ...future.result <- base::tryCatch({
[01:29:28.379]         base::withCallingHandlers({
[01:29:28.379]             ...future.value <- base::withVisible(base::local({
[01:29:28.379]                 sample(x, size = 1L)
[01:29:28.379]             }))
[01:29:28.379]             future::FutureResult(value = ...future.value$value, 
[01:29:28.379]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.379]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.379]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.379]                     ...future.globalenv.names))
[01:29:28.379]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.379]         }, condition = base::local({
[01:29:28.379]             c <- base::c
[01:29:28.379]             inherits <- base::inherits
[01:29:28.379]             invokeRestart <- base::invokeRestart
[01:29:28.379]             length <- base::length
[01:29:28.379]             list <- base::list
[01:29:28.379]             seq.int <- base::seq.int
[01:29:28.379]             signalCondition <- base::signalCondition
[01:29:28.379]             sys.calls <- base::sys.calls
[01:29:28.379]             `[[` <- base::`[[`
[01:29:28.379]             `+` <- base::`+`
[01:29:28.379]             `<<-` <- base::`<<-`
[01:29:28.379]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.379]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.379]                   3L)]
[01:29:28.379]             }
[01:29:28.379]             function(cond) {
[01:29:28.379]                 is_error <- inherits(cond, "error")
[01:29:28.379]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.379]                   NULL)
[01:29:28.379]                 if (is_error) {
[01:29:28.379]                   sessionInformation <- function() {
[01:29:28.379]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.379]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.379]                       search = base::search(), system = base::Sys.info())
[01:29:28.379]                   }
[01:29:28.379]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.379]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.379]                     cond$call), session = sessionInformation(), 
[01:29:28.379]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.379]                   signalCondition(cond)
[01:29:28.379]                 }
[01:29:28.379]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.379]                 "immediateCondition"))) {
[01:29:28.379]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.379]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.379]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.379]                   if (TRUE && !signal) {
[01:29:28.379]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.379]                     {
[01:29:28.379]                       inherits <- base::inherits
[01:29:28.379]                       invokeRestart <- base::invokeRestart
[01:29:28.379]                       is.null <- base::is.null
[01:29:28.379]                       muffled <- FALSE
[01:29:28.379]                       if (inherits(cond, "message")) {
[01:29:28.379]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.379]                         if (muffled) 
[01:29:28.379]                           invokeRestart("muffleMessage")
[01:29:28.379]                       }
[01:29:28.379]                       else if (inherits(cond, "warning")) {
[01:29:28.379]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.379]                         if (muffled) 
[01:29:28.379]                           invokeRestart("muffleWarning")
[01:29:28.379]                       }
[01:29:28.379]                       else if (inherits(cond, "condition")) {
[01:29:28.379]                         if (!is.null(pattern)) {
[01:29:28.379]                           computeRestarts <- base::computeRestarts
[01:29:28.379]                           grepl <- base::grepl
[01:29:28.379]                           restarts <- computeRestarts(cond)
[01:29:28.379]                           for (restart in restarts) {
[01:29:28.379]                             name <- restart$name
[01:29:28.379]                             if (is.null(name)) 
[01:29:28.379]                               next
[01:29:28.379]                             if (!grepl(pattern, name)) 
[01:29:28.379]                               next
[01:29:28.379]                             invokeRestart(restart)
[01:29:28.379]                             muffled <- TRUE
[01:29:28.379]                             break
[01:29:28.379]                           }
[01:29:28.379]                         }
[01:29:28.379]                       }
[01:29:28.379]                       invisible(muffled)
[01:29:28.379]                     }
[01:29:28.379]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.379]                   }
[01:29:28.379]                 }
[01:29:28.379]                 else {
[01:29:28.379]                   if (TRUE) {
[01:29:28.379]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.379]                     {
[01:29:28.379]                       inherits <- base::inherits
[01:29:28.379]                       invokeRestart <- base::invokeRestart
[01:29:28.379]                       is.null <- base::is.null
[01:29:28.379]                       muffled <- FALSE
[01:29:28.379]                       if (inherits(cond, "message")) {
[01:29:28.379]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.379]                         if (muffled) 
[01:29:28.379]                           invokeRestart("muffleMessage")
[01:29:28.379]                       }
[01:29:28.379]                       else if (inherits(cond, "warning")) {
[01:29:28.379]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.379]                         if (muffled) 
[01:29:28.379]                           invokeRestart("muffleWarning")
[01:29:28.379]                       }
[01:29:28.379]                       else if (inherits(cond, "condition")) {
[01:29:28.379]                         if (!is.null(pattern)) {
[01:29:28.379]                           computeRestarts <- base::computeRestarts
[01:29:28.379]                           grepl <- base::grepl
[01:29:28.379]                           restarts <- computeRestarts(cond)
[01:29:28.379]                           for (restart in restarts) {
[01:29:28.379]                             name <- restart$name
[01:29:28.379]                             if (is.null(name)) 
[01:29:28.379]                               next
[01:29:28.379]                             if (!grepl(pattern, name)) 
[01:29:28.379]                               next
[01:29:28.379]                             invokeRestart(restart)
[01:29:28.379]                             muffled <- TRUE
[01:29:28.379]                             break
[01:29:28.379]                           }
[01:29:28.379]                         }
[01:29:28.379]                       }
[01:29:28.379]                       invisible(muffled)
[01:29:28.379]                     }
[01:29:28.379]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.379]                   }
[01:29:28.379]                 }
[01:29:28.379]             }
[01:29:28.379]         }))
[01:29:28.379]     }, error = function(ex) {
[01:29:28.379]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.379]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.379]                 ...future.rng), started = ...future.startTime, 
[01:29:28.379]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.379]             version = "1.8"), class = "FutureResult")
[01:29:28.379]     }, finally = {
[01:29:28.379]         if (!identical(...future.workdir, getwd())) 
[01:29:28.379]             setwd(...future.workdir)
[01:29:28.379]         {
[01:29:28.379]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.379]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.379]             }
[01:29:28.379]             base::options(...future.oldOptions)
[01:29:28.379]             if (.Platform$OS.type == "windows") {
[01:29:28.379]                 old_names <- names(...future.oldEnvVars)
[01:29:28.379]                 envs <- base::Sys.getenv()
[01:29:28.379]                 names <- names(envs)
[01:29:28.379]                 common <- intersect(names, old_names)
[01:29:28.379]                 added <- setdiff(names, old_names)
[01:29:28.379]                 removed <- setdiff(old_names, names)
[01:29:28.379]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.379]                   envs[common]]
[01:29:28.379]                 NAMES <- toupper(changed)
[01:29:28.379]                 args <- list()
[01:29:28.379]                 for (kk in seq_along(NAMES)) {
[01:29:28.379]                   name <- changed[[kk]]
[01:29:28.379]                   NAME <- NAMES[[kk]]
[01:29:28.379]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.379]                     next
[01:29:28.379]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.379]                 }
[01:29:28.379]                 NAMES <- toupper(added)
[01:29:28.379]                 for (kk in seq_along(NAMES)) {
[01:29:28.379]                   name <- added[[kk]]
[01:29:28.379]                   NAME <- NAMES[[kk]]
[01:29:28.379]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.379]                     next
[01:29:28.379]                   args[[name]] <- ""
[01:29:28.379]                 }
[01:29:28.379]                 NAMES <- toupper(removed)
[01:29:28.379]                 for (kk in seq_along(NAMES)) {
[01:29:28.379]                   name <- removed[[kk]]
[01:29:28.379]                   NAME <- NAMES[[kk]]
[01:29:28.379]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.379]                     next
[01:29:28.379]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.379]                 }
[01:29:28.379]                 if (length(args) > 0) 
[01:29:28.379]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.379]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.379]             }
[01:29:28.379]             else {
[01:29:28.379]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.379]             }
[01:29:28.379]             {
[01:29:28.379]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.379]                   0L) {
[01:29:28.379]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.379]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.379]                   base::options(opts)
[01:29:28.379]                 }
[01:29:28.379]                 {
[01:29:28.379]                   {
[01:29:28.379]                     base::assign(".Random.seed", c(10407L, 32665513L, 
[01:29:28.379]                     771380658L, 382824604L, -414573498L, -284229981L, 
[01:29:28.379]                     951522791L), envir = base::globalenv(), inherits = FALSE)
[01:29:28.379]                     NULL
[01:29:28.379]                   }
[01:29:28.379]                   options(future.plan = NULL)
[01:29:28.379]                   if (is.na(NA_character_)) 
[01:29:28.379]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.379]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.379]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.379]                   {
[01:29:28.379]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.379]                     if (!future$lazy) 
[01:29:28.379]                       future <- run(future)
[01:29:28.379]                     invisible(future)
[01:29:28.379]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.379]                 }
[01:29:28.379]             }
[01:29:28.379]         }
[01:29:28.379]     })
[01:29:28.379]     if (TRUE) {
[01:29:28.379]         base::sink(type = "output", split = FALSE)
[01:29:28.379]         if (TRUE) {
[01:29:28.379]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.379]         }
[01:29:28.379]         else {
[01:29:28.379]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.379]         }
[01:29:28.379]         base::close(...future.stdout)
[01:29:28.379]         ...future.stdout <- NULL
[01:29:28.379]     }
[01:29:28.379]     ...future.result$conditions <- ...future.conditions
[01:29:28.379]     ...future.result$finished <- base::Sys.time()
[01:29:28.379]     ...future.result
[01:29:28.379] }
[01:29:28.383] assign_globals() ...
[01:29:28.383] List of 1
[01:29:28.383]  $ x: int [1:4] 0 1 2 3
[01:29:28.383]  - attr(*, "where")=List of 1
[01:29:28.383]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.383]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.383]  - attr(*, "resolved")= logi FALSE
[01:29:28.383]  - attr(*, "total_size")= num 64
[01:29:28.383]  - attr(*, "already-done")= logi TRUE
[01:29:28.387] - copied 'x' to environment
[01:29:28.388] assign_globals() ... done
[01:29:28.388] plan(): Setting new future strategy stack:
[01:29:28.388] List of future strategies:
[01:29:28.388] 1. sequential:
[01:29:28.388]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.388]    - tweaked: FALSE
[01:29:28.388]    - call: NULL
[01:29:28.389] plan(): nbrOfWorkers() = 1
[01:29:28.390] plan(): Setting new future strategy stack:
[01:29:28.390] List of future strategies:
[01:29:28.390] 1. sequential:
[01:29:28.390]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.390]    - tweaked: FALSE
[01:29:28.390]    - call: plan(strategy)
[01:29:28.391] plan(): nbrOfWorkers() = 1
[01:29:28.391] SequentialFuture started (and completed)
[01:29:28.391] - Launch lazy future ... done
[01:29:28.391] run() for 'SequentialFuture' ... done
[[1]]
[1] 0

[[2]]
[1] 2

[[3]]
[1] 3

[[4]]
[1] 3

[01:29:28.393] getGlobalsAndPackages() ...
[01:29:28.393] Searching for globals...
[01:29:28.394] - globals found: [3] '{', 'sample', 'x'
[01:29:28.394] Searching for globals ... DONE
[01:29:28.394] Resolving globals: FALSE
[01:29:28.395] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.395] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.396] - globals: [1] 'x'
[01:29:28.396] 
[01:29:28.396] getGlobalsAndPackages() ... DONE
[01:29:28.396] run() for 'Future' ...
[01:29:28.396] - state: 'created'
[01:29:28.397] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.397] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.397] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.397]   - Field: 'label'
[01:29:28.398]   - Field: 'local'
[01:29:28.398]   - Field: 'owner'
[01:29:28.398]   - Field: 'envir'
[01:29:28.398]   - Field: 'packages'
[01:29:28.398]   - Field: 'gc'
[01:29:28.398]   - Field: 'conditions'
[01:29:28.399]   - Field: 'expr'
[01:29:28.399]   - Field: 'uuid'
[01:29:28.399]   - Field: 'seed'
[01:29:28.399]   - Field: 'version'
[01:29:28.399]   - Field: 'result'
[01:29:28.399]   - Field: 'asynchronous'
[01:29:28.400]   - Field: 'calls'
[01:29:28.400]   - Field: 'globals'
[01:29:28.400]   - Field: 'stdout'
[01:29:28.400]   - Field: 'earlySignal'
[01:29:28.400]   - Field: 'lazy'
[01:29:28.401]   - Field: 'state'
[01:29:28.401] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.401] - Launch lazy future ...
[01:29:28.401] Packages needed by the future expression (n = 0): <none>
[01:29:28.401] Packages needed by future strategies (n = 0): <none>
[01:29:28.402] {
[01:29:28.402]     {
[01:29:28.402]         {
[01:29:28.402]             ...future.startTime <- base::Sys.time()
[01:29:28.402]             {
[01:29:28.402]                 {
[01:29:28.402]                   {
[01:29:28.402]                     base::local({
[01:29:28.402]                       has_future <- base::requireNamespace("future", 
[01:29:28.402]                         quietly = TRUE)
[01:29:28.402]                       if (has_future) {
[01:29:28.402]                         ns <- base::getNamespace("future")
[01:29:28.402]                         version <- ns[[".package"]][["version"]]
[01:29:28.402]                         if (is.null(version)) 
[01:29:28.402]                           version <- utils::packageVersion("future")
[01:29:28.402]                       }
[01:29:28.402]                       else {
[01:29:28.402]                         version <- NULL
[01:29:28.402]                       }
[01:29:28.402]                       if (!has_future || version < "1.8.0") {
[01:29:28.402]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.402]                           "", base::R.version$version.string), 
[01:29:28.402]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.402]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.402]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.402]                             "release", "version")], collapse = " "), 
[01:29:28.402]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.402]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.402]                           info)
[01:29:28.402]                         info <- base::paste(info, collapse = "; ")
[01:29:28.402]                         if (!has_future) {
[01:29:28.402]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.402]                             info)
[01:29:28.402]                         }
[01:29:28.402]                         else {
[01:29:28.402]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.402]                             info, version)
[01:29:28.402]                         }
[01:29:28.402]                         base::stop(msg)
[01:29:28.402]                       }
[01:29:28.402]                     })
[01:29:28.402]                   }
[01:29:28.402]                   options(future.plan = NULL)
[01:29:28.402]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.402]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.402]                 }
[01:29:28.402]                 ...future.workdir <- getwd()
[01:29:28.402]             }
[01:29:28.402]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.402]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.402]         }
[01:29:28.402]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.402]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.402]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.402]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.402]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.402]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.402]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.402]             base::names(...future.oldOptions))
[01:29:28.402]     }
[01:29:28.402]     if (FALSE) {
[01:29:28.402]     }
[01:29:28.402]     else {
[01:29:28.402]         if (TRUE) {
[01:29:28.402]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.402]                 open = "w")
[01:29:28.402]         }
[01:29:28.402]         else {
[01:29:28.402]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.402]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.402]         }
[01:29:28.402]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.402]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.402]             base::sink(type = "output", split = FALSE)
[01:29:28.402]             base::close(...future.stdout)
[01:29:28.402]         }, add = TRUE)
[01:29:28.402]     }
[01:29:28.402]     ...future.frame <- base::sys.nframe()
[01:29:28.402]     ...future.conditions <- base::list()
[01:29:28.402]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.402]     if (FALSE) {
[01:29:28.402]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.402]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.402]     }
[01:29:28.402]     ...future.result <- base::tryCatch({
[01:29:28.402]         base::withCallingHandlers({
[01:29:28.402]             ...future.value <- base::withVisible(base::local({
[01:29:28.402]                 sample(x, size = 1L)
[01:29:28.402]             }))
[01:29:28.402]             future::FutureResult(value = ...future.value$value, 
[01:29:28.402]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.402]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.402]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.402]                     ...future.globalenv.names))
[01:29:28.402]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.402]         }, condition = base::local({
[01:29:28.402]             c <- base::c
[01:29:28.402]             inherits <- base::inherits
[01:29:28.402]             invokeRestart <- base::invokeRestart
[01:29:28.402]             length <- base::length
[01:29:28.402]             list <- base::list
[01:29:28.402]             seq.int <- base::seq.int
[01:29:28.402]             signalCondition <- base::signalCondition
[01:29:28.402]             sys.calls <- base::sys.calls
[01:29:28.402]             `[[` <- base::`[[`
[01:29:28.402]             `+` <- base::`+`
[01:29:28.402]             `<<-` <- base::`<<-`
[01:29:28.402]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.402]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.402]                   3L)]
[01:29:28.402]             }
[01:29:28.402]             function(cond) {
[01:29:28.402]                 is_error <- inherits(cond, "error")
[01:29:28.402]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.402]                   NULL)
[01:29:28.402]                 if (is_error) {
[01:29:28.402]                   sessionInformation <- function() {
[01:29:28.402]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.402]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.402]                       search = base::search(), system = base::Sys.info())
[01:29:28.402]                   }
[01:29:28.402]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.402]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.402]                     cond$call), session = sessionInformation(), 
[01:29:28.402]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.402]                   signalCondition(cond)
[01:29:28.402]                 }
[01:29:28.402]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.402]                 "immediateCondition"))) {
[01:29:28.402]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.402]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.402]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.402]                   if (TRUE && !signal) {
[01:29:28.402]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.402]                     {
[01:29:28.402]                       inherits <- base::inherits
[01:29:28.402]                       invokeRestart <- base::invokeRestart
[01:29:28.402]                       is.null <- base::is.null
[01:29:28.402]                       muffled <- FALSE
[01:29:28.402]                       if (inherits(cond, "message")) {
[01:29:28.402]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.402]                         if (muffled) 
[01:29:28.402]                           invokeRestart("muffleMessage")
[01:29:28.402]                       }
[01:29:28.402]                       else if (inherits(cond, "warning")) {
[01:29:28.402]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.402]                         if (muffled) 
[01:29:28.402]                           invokeRestart("muffleWarning")
[01:29:28.402]                       }
[01:29:28.402]                       else if (inherits(cond, "condition")) {
[01:29:28.402]                         if (!is.null(pattern)) {
[01:29:28.402]                           computeRestarts <- base::computeRestarts
[01:29:28.402]                           grepl <- base::grepl
[01:29:28.402]                           restarts <- computeRestarts(cond)
[01:29:28.402]                           for (restart in restarts) {
[01:29:28.402]                             name <- restart$name
[01:29:28.402]                             if (is.null(name)) 
[01:29:28.402]                               next
[01:29:28.402]                             if (!grepl(pattern, name)) 
[01:29:28.402]                               next
[01:29:28.402]                             invokeRestart(restart)
[01:29:28.402]                             muffled <- TRUE
[01:29:28.402]                             break
[01:29:28.402]                           }
[01:29:28.402]                         }
[01:29:28.402]                       }
[01:29:28.402]                       invisible(muffled)
[01:29:28.402]                     }
[01:29:28.402]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.402]                   }
[01:29:28.402]                 }
[01:29:28.402]                 else {
[01:29:28.402]                   if (TRUE) {
[01:29:28.402]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.402]                     {
[01:29:28.402]                       inherits <- base::inherits
[01:29:28.402]                       invokeRestart <- base::invokeRestart
[01:29:28.402]                       is.null <- base::is.null
[01:29:28.402]                       muffled <- FALSE
[01:29:28.402]                       if (inherits(cond, "message")) {
[01:29:28.402]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.402]                         if (muffled) 
[01:29:28.402]                           invokeRestart("muffleMessage")
[01:29:28.402]                       }
[01:29:28.402]                       else if (inherits(cond, "warning")) {
[01:29:28.402]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.402]                         if (muffled) 
[01:29:28.402]                           invokeRestart("muffleWarning")
[01:29:28.402]                       }
[01:29:28.402]                       else if (inherits(cond, "condition")) {
[01:29:28.402]                         if (!is.null(pattern)) {
[01:29:28.402]                           computeRestarts <- base::computeRestarts
[01:29:28.402]                           grepl <- base::grepl
[01:29:28.402]                           restarts <- computeRestarts(cond)
[01:29:28.402]                           for (restart in restarts) {
[01:29:28.402]                             name <- restart$name
[01:29:28.402]                             if (is.null(name)) 
[01:29:28.402]                               next
[01:29:28.402]                             if (!grepl(pattern, name)) 
[01:29:28.402]                               next
[01:29:28.402]                             invokeRestart(restart)
[01:29:28.402]                             muffled <- TRUE
[01:29:28.402]                             break
[01:29:28.402]                           }
[01:29:28.402]                         }
[01:29:28.402]                       }
[01:29:28.402]                       invisible(muffled)
[01:29:28.402]                     }
[01:29:28.402]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.402]                   }
[01:29:28.402]                 }
[01:29:28.402]             }
[01:29:28.402]         }))
[01:29:28.402]     }, error = function(ex) {
[01:29:28.402]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.402]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.402]                 ...future.rng), started = ...future.startTime, 
[01:29:28.402]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.402]             version = "1.8"), class = "FutureResult")
[01:29:28.402]     }, finally = {
[01:29:28.402]         if (!identical(...future.workdir, getwd())) 
[01:29:28.402]             setwd(...future.workdir)
[01:29:28.402]         {
[01:29:28.402]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.402]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.402]             }
[01:29:28.402]             base::options(...future.oldOptions)
[01:29:28.402]             if (.Platform$OS.type == "windows") {
[01:29:28.402]                 old_names <- names(...future.oldEnvVars)
[01:29:28.402]                 envs <- base::Sys.getenv()
[01:29:28.402]                 names <- names(envs)
[01:29:28.402]                 common <- intersect(names, old_names)
[01:29:28.402]                 added <- setdiff(names, old_names)
[01:29:28.402]                 removed <- setdiff(old_names, names)
[01:29:28.402]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.402]                   envs[common]]
[01:29:28.402]                 NAMES <- toupper(changed)
[01:29:28.402]                 args <- list()
[01:29:28.402]                 for (kk in seq_along(NAMES)) {
[01:29:28.402]                   name <- changed[[kk]]
[01:29:28.402]                   NAME <- NAMES[[kk]]
[01:29:28.402]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.402]                     next
[01:29:28.402]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.402]                 }
[01:29:28.402]                 NAMES <- toupper(added)
[01:29:28.402]                 for (kk in seq_along(NAMES)) {
[01:29:28.402]                   name <- added[[kk]]
[01:29:28.402]                   NAME <- NAMES[[kk]]
[01:29:28.402]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.402]                     next
[01:29:28.402]                   args[[name]] <- ""
[01:29:28.402]                 }
[01:29:28.402]                 NAMES <- toupper(removed)
[01:29:28.402]                 for (kk in seq_along(NAMES)) {
[01:29:28.402]                   name <- removed[[kk]]
[01:29:28.402]                   NAME <- NAMES[[kk]]
[01:29:28.402]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.402]                     next
[01:29:28.402]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.402]                 }
[01:29:28.402]                 if (length(args) > 0) 
[01:29:28.402]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.402]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.402]             }
[01:29:28.402]             else {
[01:29:28.402]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.402]             }
[01:29:28.402]             {
[01:29:28.402]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.402]                   0L) {
[01:29:28.402]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.402]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.402]                   base::options(opts)
[01:29:28.402]                 }
[01:29:28.402]                 {
[01:29:28.402]                   {
[01:29:28.402]                     base::assign(".Random.seed", c(10407L, 1788803019L, 
[01:29:28.402]                     -2062194282L, 1512492668L, 1863688414L, -1553839187L, 
[01:29:28.402]                     -1952535076L), envir = base::globalenv(), 
[01:29:28.402]                       inherits = FALSE)
[01:29:28.402]                     NULL
[01:29:28.402]                   }
[01:29:28.402]                   options(future.plan = NULL)
[01:29:28.402]                   if (is.na(NA_character_)) 
[01:29:28.402]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.402]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.402]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.402]                   {
[01:29:28.402]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.402]                     if (!future$lazy) 
[01:29:28.402]                       future <- run(future)
[01:29:28.402]                     invisible(future)
[01:29:28.402]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.402]                 }
[01:29:28.402]             }
[01:29:28.402]         }
[01:29:28.402]     })
[01:29:28.402]     if (TRUE) {
[01:29:28.402]         base::sink(type = "output", split = FALSE)
[01:29:28.402]         if (TRUE) {
[01:29:28.402]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.402]         }
[01:29:28.402]         else {
[01:29:28.402]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.402]         }
[01:29:28.402]         base::close(...future.stdout)
[01:29:28.402]         ...future.stdout <- NULL
[01:29:28.402]     }
[01:29:28.402]     ...future.result$conditions <- ...future.conditions
[01:29:28.402]     ...future.result$finished <- base::Sys.time()
[01:29:28.402]     ...future.result
[01:29:28.402] }
[01:29:28.406] assign_globals() ...
[01:29:28.406] List of 1
[01:29:28.406]  $ x: int [1:4] 0 1 2 3
[01:29:28.406]  - attr(*, "where")=List of 1
[01:29:28.406]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.406]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.406]  - attr(*, "resolved")= logi FALSE
[01:29:28.406]  - attr(*, "total_size")= num 64
[01:29:28.406]  - attr(*, "already-done")= logi TRUE
[01:29:28.409] - copied 'x' to environment
[01:29:28.409] assign_globals() ... done
[01:29:28.409] plan(): Setting new future strategy stack:
[01:29:28.409] List of future strategies:
[01:29:28.409] 1. sequential:
[01:29:28.409]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.409]    - tweaked: FALSE
[01:29:28.409]    - call: NULL
[01:29:28.410] plan(): nbrOfWorkers() = 1
[01:29:28.411] plan(): Setting new future strategy stack:
[01:29:28.411] List of future strategies:
[01:29:28.411] 1. sequential:
[01:29:28.411]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.411]    - tweaked: FALSE
[01:29:28.411]    - call: plan(strategy)
[01:29:28.412] plan(): nbrOfWorkers() = 1
[01:29:28.412] SequentialFuture started (and completed)
[01:29:28.412] - Launch lazy future ... done
[01:29:28.413] run() for 'SequentialFuture' ... done
[01:29:28.413] getGlobalsAndPackages() ...
[01:29:28.413] Searching for globals...
[01:29:28.414] - globals found: [3] '{', 'sample', 'x'
[01:29:28.415] Searching for globals ... DONE
[01:29:28.415] Resolving globals: FALSE
[01:29:28.416] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.417] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.417] - globals: [1] 'x'
[01:29:28.417] 
[01:29:28.418] getGlobalsAndPackages() ... DONE
[01:29:28.418] run() for 'Future' ...
[01:29:28.418] - state: 'created'
[01:29:28.418] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.419] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.419] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.419]   - Field: 'label'
[01:29:28.419]   - Field: 'local'
[01:29:28.419]   - Field: 'owner'
[01:29:28.420]   - Field: 'envir'
[01:29:28.420]   - Field: 'packages'
[01:29:28.420]   - Field: 'gc'
[01:29:28.420]   - Field: 'conditions'
[01:29:28.420]   - Field: 'expr'
[01:29:28.420]   - Field: 'uuid'
[01:29:28.421]   - Field: 'seed'
[01:29:28.421]   - Field: 'version'
[01:29:28.421]   - Field: 'result'
[01:29:28.421]   - Field: 'asynchronous'
[01:29:28.421]   - Field: 'calls'
[01:29:28.422]   - Field: 'globals'
[01:29:28.422]   - Field: 'stdout'
[01:29:28.422]   - Field: 'earlySignal'
[01:29:28.422]   - Field: 'lazy'
[01:29:28.422]   - Field: 'state'
[01:29:28.422] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.423] - Launch lazy future ...
[01:29:28.423] Packages needed by the future expression (n = 0): <none>
[01:29:28.423] Packages needed by future strategies (n = 0): <none>
[01:29:28.424] {
[01:29:28.424]     {
[01:29:28.424]         {
[01:29:28.424]             ...future.startTime <- base::Sys.time()
[01:29:28.424]             {
[01:29:28.424]                 {
[01:29:28.424]                   {
[01:29:28.424]                     base::local({
[01:29:28.424]                       has_future <- base::requireNamespace("future", 
[01:29:28.424]                         quietly = TRUE)
[01:29:28.424]                       if (has_future) {
[01:29:28.424]                         ns <- base::getNamespace("future")
[01:29:28.424]                         version <- ns[[".package"]][["version"]]
[01:29:28.424]                         if (is.null(version)) 
[01:29:28.424]                           version <- utils::packageVersion("future")
[01:29:28.424]                       }
[01:29:28.424]                       else {
[01:29:28.424]                         version <- NULL
[01:29:28.424]                       }
[01:29:28.424]                       if (!has_future || version < "1.8.0") {
[01:29:28.424]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.424]                           "", base::R.version$version.string), 
[01:29:28.424]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.424]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.424]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.424]                             "release", "version")], collapse = " "), 
[01:29:28.424]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.424]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.424]                           info)
[01:29:28.424]                         info <- base::paste(info, collapse = "; ")
[01:29:28.424]                         if (!has_future) {
[01:29:28.424]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.424]                             info)
[01:29:28.424]                         }
[01:29:28.424]                         else {
[01:29:28.424]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.424]                             info, version)
[01:29:28.424]                         }
[01:29:28.424]                         base::stop(msg)
[01:29:28.424]                       }
[01:29:28.424]                     })
[01:29:28.424]                   }
[01:29:28.424]                   options(future.plan = NULL)
[01:29:28.424]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.424]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.424]                 }
[01:29:28.424]                 ...future.workdir <- getwd()
[01:29:28.424]             }
[01:29:28.424]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.424]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.424]         }
[01:29:28.424]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.424]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.424]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.424]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.424]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.424]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.424]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.424]             base::names(...future.oldOptions))
[01:29:28.424]     }
[01:29:28.424]     if (FALSE) {
[01:29:28.424]     }
[01:29:28.424]     else {
[01:29:28.424]         if (TRUE) {
[01:29:28.424]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.424]                 open = "w")
[01:29:28.424]         }
[01:29:28.424]         else {
[01:29:28.424]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.424]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.424]         }
[01:29:28.424]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.424]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.424]             base::sink(type = "output", split = FALSE)
[01:29:28.424]             base::close(...future.stdout)
[01:29:28.424]         }, add = TRUE)
[01:29:28.424]     }
[01:29:28.424]     ...future.frame <- base::sys.nframe()
[01:29:28.424]     ...future.conditions <- base::list()
[01:29:28.424]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.424]     if (FALSE) {
[01:29:28.424]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.424]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.424]     }
[01:29:28.424]     ...future.result <- base::tryCatch({
[01:29:28.424]         base::withCallingHandlers({
[01:29:28.424]             ...future.value <- base::withVisible(base::local({
[01:29:28.424]                 sample(x, size = 1L)
[01:29:28.424]             }))
[01:29:28.424]             future::FutureResult(value = ...future.value$value, 
[01:29:28.424]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.424]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.424]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.424]                     ...future.globalenv.names))
[01:29:28.424]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.424]         }, condition = base::local({
[01:29:28.424]             c <- base::c
[01:29:28.424]             inherits <- base::inherits
[01:29:28.424]             invokeRestart <- base::invokeRestart
[01:29:28.424]             length <- base::length
[01:29:28.424]             list <- base::list
[01:29:28.424]             seq.int <- base::seq.int
[01:29:28.424]             signalCondition <- base::signalCondition
[01:29:28.424]             sys.calls <- base::sys.calls
[01:29:28.424]             `[[` <- base::`[[`
[01:29:28.424]             `+` <- base::`+`
[01:29:28.424]             `<<-` <- base::`<<-`
[01:29:28.424]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.424]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.424]                   3L)]
[01:29:28.424]             }
[01:29:28.424]             function(cond) {
[01:29:28.424]                 is_error <- inherits(cond, "error")
[01:29:28.424]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.424]                   NULL)
[01:29:28.424]                 if (is_error) {
[01:29:28.424]                   sessionInformation <- function() {
[01:29:28.424]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.424]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.424]                       search = base::search(), system = base::Sys.info())
[01:29:28.424]                   }
[01:29:28.424]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.424]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.424]                     cond$call), session = sessionInformation(), 
[01:29:28.424]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.424]                   signalCondition(cond)
[01:29:28.424]                 }
[01:29:28.424]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.424]                 "immediateCondition"))) {
[01:29:28.424]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.424]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.424]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.424]                   if (TRUE && !signal) {
[01:29:28.424]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.424]                     {
[01:29:28.424]                       inherits <- base::inherits
[01:29:28.424]                       invokeRestart <- base::invokeRestart
[01:29:28.424]                       is.null <- base::is.null
[01:29:28.424]                       muffled <- FALSE
[01:29:28.424]                       if (inherits(cond, "message")) {
[01:29:28.424]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.424]                         if (muffled) 
[01:29:28.424]                           invokeRestart("muffleMessage")
[01:29:28.424]                       }
[01:29:28.424]                       else if (inherits(cond, "warning")) {
[01:29:28.424]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.424]                         if (muffled) 
[01:29:28.424]                           invokeRestart("muffleWarning")
[01:29:28.424]                       }
[01:29:28.424]                       else if (inherits(cond, "condition")) {
[01:29:28.424]                         if (!is.null(pattern)) {
[01:29:28.424]                           computeRestarts <- base::computeRestarts
[01:29:28.424]                           grepl <- base::grepl
[01:29:28.424]                           restarts <- computeRestarts(cond)
[01:29:28.424]                           for (restart in restarts) {
[01:29:28.424]                             name <- restart$name
[01:29:28.424]                             if (is.null(name)) 
[01:29:28.424]                               next
[01:29:28.424]                             if (!grepl(pattern, name)) 
[01:29:28.424]                               next
[01:29:28.424]                             invokeRestart(restart)
[01:29:28.424]                             muffled <- TRUE
[01:29:28.424]                             break
[01:29:28.424]                           }
[01:29:28.424]                         }
[01:29:28.424]                       }
[01:29:28.424]                       invisible(muffled)
[01:29:28.424]                     }
[01:29:28.424]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.424]                   }
[01:29:28.424]                 }
[01:29:28.424]                 else {
[01:29:28.424]                   if (TRUE) {
[01:29:28.424]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.424]                     {
[01:29:28.424]                       inherits <- base::inherits
[01:29:28.424]                       invokeRestart <- base::invokeRestart
[01:29:28.424]                       is.null <- base::is.null
[01:29:28.424]                       muffled <- FALSE
[01:29:28.424]                       if (inherits(cond, "message")) {
[01:29:28.424]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.424]                         if (muffled) 
[01:29:28.424]                           invokeRestart("muffleMessage")
[01:29:28.424]                       }
[01:29:28.424]                       else if (inherits(cond, "warning")) {
[01:29:28.424]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.424]                         if (muffled) 
[01:29:28.424]                           invokeRestart("muffleWarning")
[01:29:28.424]                       }
[01:29:28.424]                       else if (inherits(cond, "condition")) {
[01:29:28.424]                         if (!is.null(pattern)) {
[01:29:28.424]                           computeRestarts <- base::computeRestarts
[01:29:28.424]                           grepl <- base::grepl
[01:29:28.424]                           restarts <- computeRestarts(cond)
[01:29:28.424]                           for (restart in restarts) {
[01:29:28.424]                             name <- restart$name
[01:29:28.424]                             if (is.null(name)) 
[01:29:28.424]                               next
[01:29:28.424]                             if (!grepl(pattern, name)) 
[01:29:28.424]                               next
[01:29:28.424]                             invokeRestart(restart)
[01:29:28.424]                             muffled <- TRUE
[01:29:28.424]                             break
[01:29:28.424]                           }
[01:29:28.424]                         }
[01:29:28.424]                       }
[01:29:28.424]                       invisible(muffled)
[01:29:28.424]                     }
[01:29:28.424]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.424]                   }
[01:29:28.424]                 }
[01:29:28.424]             }
[01:29:28.424]         }))
[01:29:28.424]     }, error = function(ex) {
[01:29:28.424]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.424]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.424]                 ...future.rng), started = ...future.startTime, 
[01:29:28.424]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.424]             version = "1.8"), class = "FutureResult")
[01:29:28.424]     }, finally = {
[01:29:28.424]         if (!identical(...future.workdir, getwd())) 
[01:29:28.424]             setwd(...future.workdir)
[01:29:28.424]         {
[01:29:28.424]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.424]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.424]             }
[01:29:28.424]             base::options(...future.oldOptions)
[01:29:28.424]             if (.Platform$OS.type == "windows") {
[01:29:28.424]                 old_names <- names(...future.oldEnvVars)
[01:29:28.424]                 envs <- base::Sys.getenv()
[01:29:28.424]                 names <- names(envs)
[01:29:28.424]                 common <- intersect(names, old_names)
[01:29:28.424]                 added <- setdiff(names, old_names)
[01:29:28.424]                 removed <- setdiff(old_names, names)
[01:29:28.424]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.424]                   envs[common]]
[01:29:28.424]                 NAMES <- toupper(changed)
[01:29:28.424]                 args <- list()
[01:29:28.424]                 for (kk in seq_along(NAMES)) {
[01:29:28.424]                   name <- changed[[kk]]
[01:29:28.424]                   NAME <- NAMES[[kk]]
[01:29:28.424]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.424]                     next
[01:29:28.424]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.424]                 }
[01:29:28.424]                 NAMES <- toupper(added)
[01:29:28.424]                 for (kk in seq_along(NAMES)) {
[01:29:28.424]                   name <- added[[kk]]
[01:29:28.424]                   NAME <- NAMES[[kk]]
[01:29:28.424]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.424]                     next
[01:29:28.424]                   args[[name]] <- ""
[01:29:28.424]                 }
[01:29:28.424]                 NAMES <- toupper(removed)
[01:29:28.424]                 for (kk in seq_along(NAMES)) {
[01:29:28.424]                   name <- removed[[kk]]
[01:29:28.424]                   NAME <- NAMES[[kk]]
[01:29:28.424]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.424]                     next
[01:29:28.424]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.424]                 }
[01:29:28.424]                 if (length(args) > 0) 
[01:29:28.424]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.424]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.424]             }
[01:29:28.424]             else {
[01:29:28.424]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.424]             }
[01:29:28.424]             {
[01:29:28.424]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.424]                   0L) {
[01:29:28.424]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.424]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.424]                   base::options(opts)
[01:29:28.424]                 }
[01:29:28.424]                 {
[01:29:28.424]                   {
[01:29:28.424]                     base::assign(".Random.seed", c(10407L, 1512492668L, 
[01:29:28.424]                     -1424970269L, -874615779L, -1952535076L, 
[01:29:28.424]                     -2035996805L, -360807571L), envir = base::globalenv(), 
[01:29:28.424]                       inherits = FALSE)
[01:29:28.424]                     NULL
[01:29:28.424]                   }
[01:29:28.424]                   options(future.plan = NULL)
[01:29:28.424]                   if (is.na(NA_character_)) 
[01:29:28.424]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.424]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.424]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.424]                   {
[01:29:28.424]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.424]                     if (!future$lazy) 
[01:29:28.424]                       future <- run(future)
[01:29:28.424]                     invisible(future)
[01:29:28.424]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.424]                 }
[01:29:28.424]             }
[01:29:28.424]         }
[01:29:28.424]     })
[01:29:28.424]     if (TRUE) {
[01:29:28.424]         base::sink(type = "output", split = FALSE)
[01:29:28.424]         if (TRUE) {
[01:29:28.424]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.424]         }
[01:29:28.424]         else {
[01:29:28.424]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.424]         }
[01:29:28.424]         base::close(...future.stdout)
[01:29:28.424]         ...future.stdout <- NULL
[01:29:28.424]     }
[01:29:28.424]     ...future.result$conditions <- ...future.conditions
[01:29:28.424]     ...future.result$finished <- base::Sys.time()
[01:29:28.424]     ...future.result
[01:29:28.424] }
[01:29:28.427] assign_globals() ...
[01:29:28.428] List of 1
[01:29:28.428]  $ x: int [1:4] 0 1 2 3
[01:29:28.428]  - attr(*, "where")=List of 1
[01:29:28.428]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.428]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.428]  - attr(*, "resolved")= logi FALSE
[01:29:28.428]  - attr(*, "total_size")= num 64
[01:29:28.428]  - attr(*, "already-done")= logi TRUE
[01:29:28.430] - copied 'x' to environment
[01:29:28.431] assign_globals() ... done
[01:29:28.431] plan(): Setting new future strategy stack:
[01:29:28.431] List of future strategies:
[01:29:28.431] 1. sequential:
[01:29:28.431]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.431]    - tweaked: FALSE
[01:29:28.431]    - call: NULL
[01:29:28.432] plan(): nbrOfWorkers() = 1
[01:29:28.433] plan(): Setting new future strategy stack:
[01:29:28.433] List of future strategies:
[01:29:28.433] 1. sequential:
[01:29:28.433]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.433]    - tweaked: FALSE
[01:29:28.433]    - call: plan(strategy)
[01:29:28.434] plan(): nbrOfWorkers() = 1
[01:29:28.434] SequentialFuture started (and completed)
[01:29:28.434] - Launch lazy future ... done
[01:29:28.434] run() for 'SequentialFuture' ... done
[01:29:28.435] getGlobalsAndPackages() ...
[01:29:28.435] Searching for globals...
[01:29:28.436] - globals found: [3] '{', 'sample', 'x'
[01:29:28.436] Searching for globals ... DONE
[01:29:28.437] Resolving globals: FALSE
[01:29:28.437] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.438] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.438] - globals: [1] 'x'
[01:29:28.438] 
[01:29:28.438] getGlobalsAndPackages() ... DONE
[01:29:28.439] run() for 'Future' ...
[01:29:28.439] - state: 'created'
[01:29:28.439] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.439] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.440] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.440]   - Field: 'label'
[01:29:28.440]   - Field: 'local'
[01:29:28.440]   - Field: 'owner'
[01:29:28.441]   - Field: 'envir'
[01:29:28.441]   - Field: 'packages'
[01:29:28.441]   - Field: 'gc'
[01:29:28.441]   - Field: 'conditions'
[01:29:28.441]   - Field: 'expr'
[01:29:28.442]   - Field: 'uuid'
[01:29:28.442]   - Field: 'seed'
[01:29:28.442]   - Field: 'version'
[01:29:28.442]   - Field: 'result'
[01:29:28.443]   - Field: 'asynchronous'
[01:29:28.443]   - Field: 'calls'
[01:29:28.443]   - Field: 'globals'
[01:29:28.443]   - Field: 'stdout'
[01:29:28.443]   - Field: 'earlySignal'
[01:29:28.443]   - Field: 'lazy'
[01:29:28.444]   - Field: 'state'
[01:29:28.444] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.444] - Launch lazy future ...
[01:29:28.444] Packages needed by the future expression (n = 0): <none>
[01:29:28.445] Packages needed by future strategies (n = 0): <none>
[01:29:28.445] {
[01:29:28.445]     {
[01:29:28.445]         {
[01:29:28.445]             ...future.startTime <- base::Sys.time()
[01:29:28.445]             {
[01:29:28.445]                 {
[01:29:28.445]                   {
[01:29:28.445]                     base::local({
[01:29:28.445]                       has_future <- base::requireNamespace("future", 
[01:29:28.445]                         quietly = TRUE)
[01:29:28.445]                       if (has_future) {
[01:29:28.445]                         ns <- base::getNamespace("future")
[01:29:28.445]                         version <- ns[[".package"]][["version"]]
[01:29:28.445]                         if (is.null(version)) 
[01:29:28.445]                           version <- utils::packageVersion("future")
[01:29:28.445]                       }
[01:29:28.445]                       else {
[01:29:28.445]                         version <- NULL
[01:29:28.445]                       }
[01:29:28.445]                       if (!has_future || version < "1.8.0") {
[01:29:28.445]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.445]                           "", base::R.version$version.string), 
[01:29:28.445]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.445]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.445]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.445]                             "release", "version")], collapse = " "), 
[01:29:28.445]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.445]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.445]                           info)
[01:29:28.445]                         info <- base::paste(info, collapse = "; ")
[01:29:28.445]                         if (!has_future) {
[01:29:28.445]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.445]                             info)
[01:29:28.445]                         }
[01:29:28.445]                         else {
[01:29:28.445]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.445]                             info, version)
[01:29:28.445]                         }
[01:29:28.445]                         base::stop(msg)
[01:29:28.445]                       }
[01:29:28.445]                     })
[01:29:28.445]                   }
[01:29:28.445]                   options(future.plan = NULL)
[01:29:28.445]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.445]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.445]                 }
[01:29:28.445]                 ...future.workdir <- getwd()
[01:29:28.445]             }
[01:29:28.445]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.445]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.445]         }
[01:29:28.445]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.445]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.445]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.445]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.445]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.445]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.445]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.445]             base::names(...future.oldOptions))
[01:29:28.445]     }
[01:29:28.445]     if (FALSE) {
[01:29:28.445]     }
[01:29:28.445]     else {
[01:29:28.445]         if (TRUE) {
[01:29:28.445]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.445]                 open = "w")
[01:29:28.445]         }
[01:29:28.445]         else {
[01:29:28.445]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.445]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.445]         }
[01:29:28.445]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.445]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.445]             base::sink(type = "output", split = FALSE)
[01:29:28.445]             base::close(...future.stdout)
[01:29:28.445]         }, add = TRUE)
[01:29:28.445]     }
[01:29:28.445]     ...future.frame <- base::sys.nframe()
[01:29:28.445]     ...future.conditions <- base::list()
[01:29:28.445]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.445]     if (FALSE) {
[01:29:28.445]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.445]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.445]     }
[01:29:28.445]     ...future.result <- base::tryCatch({
[01:29:28.445]         base::withCallingHandlers({
[01:29:28.445]             ...future.value <- base::withVisible(base::local({
[01:29:28.445]                 sample(x, size = 1L)
[01:29:28.445]             }))
[01:29:28.445]             future::FutureResult(value = ...future.value$value, 
[01:29:28.445]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.445]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.445]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.445]                     ...future.globalenv.names))
[01:29:28.445]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.445]         }, condition = base::local({
[01:29:28.445]             c <- base::c
[01:29:28.445]             inherits <- base::inherits
[01:29:28.445]             invokeRestart <- base::invokeRestart
[01:29:28.445]             length <- base::length
[01:29:28.445]             list <- base::list
[01:29:28.445]             seq.int <- base::seq.int
[01:29:28.445]             signalCondition <- base::signalCondition
[01:29:28.445]             sys.calls <- base::sys.calls
[01:29:28.445]             `[[` <- base::`[[`
[01:29:28.445]             `+` <- base::`+`
[01:29:28.445]             `<<-` <- base::`<<-`
[01:29:28.445]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.445]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.445]                   3L)]
[01:29:28.445]             }
[01:29:28.445]             function(cond) {
[01:29:28.445]                 is_error <- inherits(cond, "error")
[01:29:28.445]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.445]                   NULL)
[01:29:28.445]                 if (is_error) {
[01:29:28.445]                   sessionInformation <- function() {
[01:29:28.445]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.445]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.445]                       search = base::search(), system = base::Sys.info())
[01:29:28.445]                   }
[01:29:28.445]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.445]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.445]                     cond$call), session = sessionInformation(), 
[01:29:28.445]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.445]                   signalCondition(cond)
[01:29:28.445]                 }
[01:29:28.445]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.445]                 "immediateCondition"))) {
[01:29:28.445]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.445]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.445]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.445]                   if (TRUE && !signal) {
[01:29:28.445]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.445]                     {
[01:29:28.445]                       inherits <- base::inherits
[01:29:28.445]                       invokeRestart <- base::invokeRestart
[01:29:28.445]                       is.null <- base::is.null
[01:29:28.445]                       muffled <- FALSE
[01:29:28.445]                       if (inherits(cond, "message")) {
[01:29:28.445]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.445]                         if (muffled) 
[01:29:28.445]                           invokeRestart("muffleMessage")
[01:29:28.445]                       }
[01:29:28.445]                       else if (inherits(cond, "warning")) {
[01:29:28.445]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.445]                         if (muffled) 
[01:29:28.445]                           invokeRestart("muffleWarning")
[01:29:28.445]                       }
[01:29:28.445]                       else if (inherits(cond, "condition")) {
[01:29:28.445]                         if (!is.null(pattern)) {
[01:29:28.445]                           computeRestarts <- base::computeRestarts
[01:29:28.445]                           grepl <- base::grepl
[01:29:28.445]                           restarts <- computeRestarts(cond)
[01:29:28.445]                           for (restart in restarts) {
[01:29:28.445]                             name <- restart$name
[01:29:28.445]                             if (is.null(name)) 
[01:29:28.445]                               next
[01:29:28.445]                             if (!grepl(pattern, name)) 
[01:29:28.445]                               next
[01:29:28.445]                             invokeRestart(restart)
[01:29:28.445]                             muffled <- TRUE
[01:29:28.445]                             break
[01:29:28.445]                           }
[01:29:28.445]                         }
[01:29:28.445]                       }
[01:29:28.445]                       invisible(muffled)
[01:29:28.445]                     }
[01:29:28.445]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.445]                   }
[01:29:28.445]                 }
[01:29:28.445]                 else {
[01:29:28.445]                   if (TRUE) {
[01:29:28.445]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.445]                     {
[01:29:28.445]                       inherits <- base::inherits
[01:29:28.445]                       invokeRestart <- base::invokeRestart
[01:29:28.445]                       is.null <- base::is.null
[01:29:28.445]                       muffled <- FALSE
[01:29:28.445]                       if (inherits(cond, "message")) {
[01:29:28.445]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.445]                         if (muffled) 
[01:29:28.445]                           invokeRestart("muffleMessage")
[01:29:28.445]                       }
[01:29:28.445]                       else if (inherits(cond, "warning")) {
[01:29:28.445]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.445]                         if (muffled) 
[01:29:28.445]                           invokeRestart("muffleWarning")
[01:29:28.445]                       }
[01:29:28.445]                       else if (inherits(cond, "condition")) {
[01:29:28.445]                         if (!is.null(pattern)) {
[01:29:28.445]                           computeRestarts <- base::computeRestarts
[01:29:28.445]                           grepl <- base::grepl
[01:29:28.445]                           restarts <- computeRestarts(cond)
[01:29:28.445]                           for (restart in restarts) {
[01:29:28.445]                             name <- restart$name
[01:29:28.445]                             if (is.null(name)) 
[01:29:28.445]                               next
[01:29:28.445]                             if (!grepl(pattern, name)) 
[01:29:28.445]                               next
[01:29:28.445]                             invokeRestart(restart)
[01:29:28.445]                             muffled <- TRUE
[01:29:28.445]                             break
[01:29:28.445]                           }
[01:29:28.445]                         }
[01:29:28.445]                       }
[01:29:28.445]                       invisible(muffled)
[01:29:28.445]                     }
[01:29:28.445]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.445]                   }
[01:29:28.445]                 }
[01:29:28.445]             }
[01:29:28.445]         }))
[01:29:28.445]     }, error = function(ex) {
[01:29:28.445]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.445]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.445]                 ...future.rng), started = ...future.startTime, 
[01:29:28.445]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.445]             version = "1.8"), class = "FutureResult")
[01:29:28.445]     }, finally = {
[01:29:28.445]         if (!identical(...future.workdir, getwd())) 
[01:29:28.445]             setwd(...future.workdir)
[01:29:28.445]         {
[01:29:28.445]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.445]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.445]             }
[01:29:28.445]             base::options(...future.oldOptions)
[01:29:28.445]             if (.Platform$OS.type == "windows") {
[01:29:28.445]                 old_names <- names(...future.oldEnvVars)
[01:29:28.445]                 envs <- base::Sys.getenv()
[01:29:28.445]                 names <- names(envs)
[01:29:28.445]                 common <- intersect(names, old_names)
[01:29:28.445]                 added <- setdiff(names, old_names)
[01:29:28.445]                 removed <- setdiff(old_names, names)
[01:29:28.445]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.445]                   envs[common]]
[01:29:28.445]                 NAMES <- toupper(changed)
[01:29:28.445]                 args <- list()
[01:29:28.445]                 for (kk in seq_along(NAMES)) {
[01:29:28.445]                   name <- changed[[kk]]
[01:29:28.445]                   NAME <- NAMES[[kk]]
[01:29:28.445]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.445]                     next
[01:29:28.445]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.445]                 }
[01:29:28.445]                 NAMES <- toupper(added)
[01:29:28.445]                 for (kk in seq_along(NAMES)) {
[01:29:28.445]                   name <- added[[kk]]
[01:29:28.445]                   NAME <- NAMES[[kk]]
[01:29:28.445]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.445]                     next
[01:29:28.445]                   args[[name]] <- ""
[01:29:28.445]                 }
[01:29:28.445]                 NAMES <- toupper(removed)
[01:29:28.445]                 for (kk in seq_along(NAMES)) {
[01:29:28.445]                   name <- removed[[kk]]
[01:29:28.445]                   NAME <- NAMES[[kk]]
[01:29:28.445]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.445]                     next
[01:29:28.445]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.445]                 }
[01:29:28.445]                 if (length(args) > 0) 
[01:29:28.445]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.445]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.445]             }
[01:29:28.445]             else {
[01:29:28.445]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.445]             }
[01:29:28.445]             {
[01:29:28.445]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.445]                   0L) {
[01:29:28.445]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.445]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.445]                   base::options(opts)
[01:29:28.445]                 }
[01:29:28.445]                 {
[01:29:28.445]                   {
[01:29:28.445]                     base::assign(".Random.seed", c(10407L, -874615779L, 
[01:29:28.445]                     858954295L, 1745775247L, -360807571L, -322333159L, 
[01:29:28.445]                     1509109739L), envir = base::globalenv(), 
[01:29:28.445]                       inherits = FALSE)
[01:29:28.445]                     NULL
[01:29:28.445]                   }
[01:29:28.445]                   options(future.plan = NULL)
[01:29:28.445]                   if (is.na(NA_character_)) 
[01:29:28.445]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.445]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.445]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.445]                   {
[01:29:28.445]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.445]                     if (!future$lazy) 
[01:29:28.445]                       future <- run(future)
[01:29:28.445]                     invisible(future)
[01:29:28.445]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.445]                 }
[01:29:28.445]             }
[01:29:28.445]         }
[01:29:28.445]     })
[01:29:28.445]     if (TRUE) {
[01:29:28.445]         base::sink(type = "output", split = FALSE)
[01:29:28.445]         if (TRUE) {
[01:29:28.445]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.445]         }
[01:29:28.445]         else {
[01:29:28.445]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.445]         }
[01:29:28.445]         base::close(...future.stdout)
[01:29:28.445]         ...future.stdout <- NULL
[01:29:28.445]     }
[01:29:28.445]     ...future.result$conditions <- ...future.conditions
[01:29:28.445]     ...future.result$finished <- base::Sys.time()
[01:29:28.445]     ...future.result
[01:29:28.445] }
[01:29:28.449] assign_globals() ...
[01:29:28.449] List of 1
[01:29:28.449]  $ x: int [1:4] 0 1 2 3
[01:29:28.449]  - attr(*, "where")=List of 1
[01:29:28.449]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.449]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.449]  - attr(*, "resolved")= logi FALSE
[01:29:28.449]  - attr(*, "total_size")= num 64
[01:29:28.449]  - attr(*, "already-done")= logi TRUE
[01:29:28.456] - copied 'x' to environment
[01:29:28.456] assign_globals() ... done
[01:29:28.456] plan(): Setting new future strategy stack:
[01:29:28.457] List of future strategies:
[01:29:28.457] 1. sequential:
[01:29:28.457]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.457]    - tweaked: FALSE
[01:29:28.457]    - call: NULL
[01:29:28.457] plan(): nbrOfWorkers() = 1
[01:29:28.459] plan(): Setting new future strategy stack:
[01:29:28.459] List of future strategies:
[01:29:28.459] 1. sequential:
[01:29:28.459]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.459]    - tweaked: FALSE
[01:29:28.459]    - call: plan(strategy)
[01:29:28.460] plan(): nbrOfWorkers() = 1
[01:29:28.460] SequentialFuture started (and completed)
[01:29:28.460] - Launch lazy future ... done
[01:29:28.461] run() for 'SequentialFuture' ... done
[01:29:28.461] getGlobalsAndPackages() ...
[01:29:28.461] Searching for globals...
[01:29:28.463] - globals found: [3] '{', 'sample', 'x'
[01:29:28.463] Searching for globals ... DONE
[01:29:28.463] Resolving globals: FALSE
[01:29:28.464] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.464] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.465] - globals: [1] 'x'
[01:29:28.465] 
[01:29:28.465] getGlobalsAndPackages() ... DONE
[01:29:28.465] run() for 'Future' ...
[01:29:28.466] - state: 'created'
[01:29:28.466] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.466] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.466] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.467]   - Field: 'label'
[01:29:28.467]   - Field: 'local'
[01:29:28.467]   - Field: 'owner'
[01:29:28.467]   - Field: 'envir'
[01:29:28.468]   - Field: 'packages'
[01:29:28.468]   - Field: 'gc'
[01:29:28.468]   - Field: 'conditions'
[01:29:28.468]   - Field: 'expr'
[01:29:28.468]   - Field: 'uuid'
[01:29:28.469]   - Field: 'seed'
[01:29:28.469]   - Field: 'version'
[01:29:28.469]   - Field: 'result'
[01:29:28.469]   - Field: 'asynchronous'
[01:29:28.469]   - Field: 'calls'
[01:29:28.470]   - Field: 'globals'
[01:29:28.470]   - Field: 'stdout'
[01:29:28.470]   - Field: 'earlySignal'
[01:29:28.470]   - Field: 'lazy'
[01:29:28.470]   - Field: 'state'
[01:29:28.471] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.471] - Launch lazy future ...
[01:29:28.471] Packages needed by the future expression (n = 0): <none>
[01:29:28.471] Packages needed by future strategies (n = 0): <none>
[01:29:28.472] {
[01:29:28.472]     {
[01:29:28.472]         {
[01:29:28.472]             ...future.startTime <- base::Sys.time()
[01:29:28.472]             {
[01:29:28.472]                 {
[01:29:28.472]                   {
[01:29:28.472]                     base::local({
[01:29:28.472]                       has_future <- base::requireNamespace("future", 
[01:29:28.472]                         quietly = TRUE)
[01:29:28.472]                       if (has_future) {
[01:29:28.472]                         ns <- base::getNamespace("future")
[01:29:28.472]                         version <- ns[[".package"]][["version"]]
[01:29:28.472]                         if (is.null(version)) 
[01:29:28.472]                           version <- utils::packageVersion("future")
[01:29:28.472]                       }
[01:29:28.472]                       else {
[01:29:28.472]                         version <- NULL
[01:29:28.472]                       }
[01:29:28.472]                       if (!has_future || version < "1.8.0") {
[01:29:28.472]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.472]                           "", base::R.version$version.string), 
[01:29:28.472]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.472]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.472]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.472]                             "release", "version")], collapse = " "), 
[01:29:28.472]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.472]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.472]                           info)
[01:29:28.472]                         info <- base::paste(info, collapse = "; ")
[01:29:28.472]                         if (!has_future) {
[01:29:28.472]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.472]                             info)
[01:29:28.472]                         }
[01:29:28.472]                         else {
[01:29:28.472]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.472]                             info, version)
[01:29:28.472]                         }
[01:29:28.472]                         base::stop(msg)
[01:29:28.472]                       }
[01:29:28.472]                     })
[01:29:28.472]                   }
[01:29:28.472]                   options(future.plan = NULL)
[01:29:28.472]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.472]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.472]                 }
[01:29:28.472]                 ...future.workdir <- getwd()
[01:29:28.472]             }
[01:29:28.472]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.472]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.472]         }
[01:29:28.472]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.472]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.472]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.472]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.472]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.472]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.472]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.472]             base::names(...future.oldOptions))
[01:29:28.472]     }
[01:29:28.472]     if (FALSE) {
[01:29:28.472]     }
[01:29:28.472]     else {
[01:29:28.472]         if (TRUE) {
[01:29:28.472]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.472]                 open = "w")
[01:29:28.472]         }
[01:29:28.472]         else {
[01:29:28.472]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.472]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.472]         }
[01:29:28.472]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.472]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.472]             base::sink(type = "output", split = FALSE)
[01:29:28.472]             base::close(...future.stdout)
[01:29:28.472]         }, add = TRUE)
[01:29:28.472]     }
[01:29:28.472]     ...future.frame <- base::sys.nframe()
[01:29:28.472]     ...future.conditions <- base::list()
[01:29:28.472]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.472]     if (FALSE) {
[01:29:28.472]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.472]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.472]     }
[01:29:28.472]     ...future.result <- base::tryCatch({
[01:29:28.472]         base::withCallingHandlers({
[01:29:28.472]             ...future.value <- base::withVisible(base::local({
[01:29:28.472]                 sample(x, size = 1L)
[01:29:28.472]             }))
[01:29:28.472]             future::FutureResult(value = ...future.value$value, 
[01:29:28.472]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.472]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.472]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.472]                     ...future.globalenv.names))
[01:29:28.472]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.472]         }, condition = base::local({
[01:29:28.472]             c <- base::c
[01:29:28.472]             inherits <- base::inherits
[01:29:28.472]             invokeRestart <- base::invokeRestart
[01:29:28.472]             length <- base::length
[01:29:28.472]             list <- base::list
[01:29:28.472]             seq.int <- base::seq.int
[01:29:28.472]             signalCondition <- base::signalCondition
[01:29:28.472]             sys.calls <- base::sys.calls
[01:29:28.472]             `[[` <- base::`[[`
[01:29:28.472]             `+` <- base::`+`
[01:29:28.472]             `<<-` <- base::`<<-`
[01:29:28.472]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.472]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.472]                   3L)]
[01:29:28.472]             }
[01:29:28.472]             function(cond) {
[01:29:28.472]                 is_error <- inherits(cond, "error")
[01:29:28.472]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.472]                   NULL)
[01:29:28.472]                 if (is_error) {
[01:29:28.472]                   sessionInformation <- function() {
[01:29:28.472]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.472]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.472]                       search = base::search(), system = base::Sys.info())
[01:29:28.472]                   }
[01:29:28.472]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.472]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.472]                     cond$call), session = sessionInformation(), 
[01:29:28.472]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.472]                   signalCondition(cond)
[01:29:28.472]                 }
[01:29:28.472]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.472]                 "immediateCondition"))) {
[01:29:28.472]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.472]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.472]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.472]                   if (TRUE && !signal) {
[01:29:28.472]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.472]                     {
[01:29:28.472]                       inherits <- base::inherits
[01:29:28.472]                       invokeRestart <- base::invokeRestart
[01:29:28.472]                       is.null <- base::is.null
[01:29:28.472]                       muffled <- FALSE
[01:29:28.472]                       if (inherits(cond, "message")) {
[01:29:28.472]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.472]                         if (muffled) 
[01:29:28.472]                           invokeRestart("muffleMessage")
[01:29:28.472]                       }
[01:29:28.472]                       else if (inherits(cond, "warning")) {
[01:29:28.472]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.472]                         if (muffled) 
[01:29:28.472]                           invokeRestart("muffleWarning")
[01:29:28.472]                       }
[01:29:28.472]                       else if (inherits(cond, "condition")) {
[01:29:28.472]                         if (!is.null(pattern)) {
[01:29:28.472]                           computeRestarts <- base::computeRestarts
[01:29:28.472]                           grepl <- base::grepl
[01:29:28.472]                           restarts <- computeRestarts(cond)
[01:29:28.472]                           for (restart in restarts) {
[01:29:28.472]                             name <- restart$name
[01:29:28.472]                             if (is.null(name)) 
[01:29:28.472]                               next
[01:29:28.472]                             if (!grepl(pattern, name)) 
[01:29:28.472]                               next
[01:29:28.472]                             invokeRestart(restart)
[01:29:28.472]                             muffled <- TRUE
[01:29:28.472]                             break
[01:29:28.472]                           }
[01:29:28.472]                         }
[01:29:28.472]                       }
[01:29:28.472]                       invisible(muffled)
[01:29:28.472]                     }
[01:29:28.472]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.472]                   }
[01:29:28.472]                 }
[01:29:28.472]                 else {
[01:29:28.472]                   if (TRUE) {
[01:29:28.472]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.472]                     {
[01:29:28.472]                       inherits <- base::inherits
[01:29:28.472]                       invokeRestart <- base::invokeRestart
[01:29:28.472]                       is.null <- base::is.null
[01:29:28.472]                       muffled <- FALSE
[01:29:28.472]                       if (inherits(cond, "message")) {
[01:29:28.472]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.472]                         if (muffled) 
[01:29:28.472]                           invokeRestart("muffleMessage")
[01:29:28.472]                       }
[01:29:28.472]                       else if (inherits(cond, "warning")) {
[01:29:28.472]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.472]                         if (muffled) 
[01:29:28.472]                           invokeRestart("muffleWarning")
[01:29:28.472]                       }
[01:29:28.472]                       else if (inherits(cond, "condition")) {
[01:29:28.472]                         if (!is.null(pattern)) {
[01:29:28.472]                           computeRestarts <- base::computeRestarts
[01:29:28.472]                           grepl <- base::grepl
[01:29:28.472]                           restarts <- computeRestarts(cond)
[01:29:28.472]                           for (restart in restarts) {
[01:29:28.472]                             name <- restart$name
[01:29:28.472]                             if (is.null(name)) 
[01:29:28.472]                               next
[01:29:28.472]                             if (!grepl(pattern, name)) 
[01:29:28.472]                               next
[01:29:28.472]                             invokeRestart(restart)
[01:29:28.472]                             muffled <- TRUE
[01:29:28.472]                             break
[01:29:28.472]                           }
[01:29:28.472]                         }
[01:29:28.472]                       }
[01:29:28.472]                       invisible(muffled)
[01:29:28.472]                     }
[01:29:28.472]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.472]                   }
[01:29:28.472]                 }
[01:29:28.472]             }
[01:29:28.472]         }))
[01:29:28.472]     }, error = function(ex) {
[01:29:28.472]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.472]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.472]                 ...future.rng), started = ...future.startTime, 
[01:29:28.472]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.472]             version = "1.8"), class = "FutureResult")
[01:29:28.472]     }, finally = {
[01:29:28.472]         if (!identical(...future.workdir, getwd())) 
[01:29:28.472]             setwd(...future.workdir)
[01:29:28.472]         {
[01:29:28.472]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.472]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.472]             }
[01:29:28.472]             base::options(...future.oldOptions)
[01:29:28.472]             if (.Platform$OS.type == "windows") {
[01:29:28.472]                 old_names <- names(...future.oldEnvVars)
[01:29:28.472]                 envs <- base::Sys.getenv()
[01:29:28.472]                 names <- names(envs)
[01:29:28.472]                 common <- intersect(names, old_names)
[01:29:28.472]                 added <- setdiff(names, old_names)
[01:29:28.472]                 removed <- setdiff(old_names, names)
[01:29:28.472]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.472]                   envs[common]]
[01:29:28.472]                 NAMES <- toupper(changed)
[01:29:28.472]                 args <- list()
[01:29:28.472]                 for (kk in seq_along(NAMES)) {
[01:29:28.472]                   name <- changed[[kk]]
[01:29:28.472]                   NAME <- NAMES[[kk]]
[01:29:28.472]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.472]                     next
[01:29:28.472]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.472]                 }
[01:29:28.472]                 NAMES <- toupper(added)
[01:29:28.472]                 for (kk in seq_along(NAMES)) {
[01:29:28.472]                   name <- added[[kk]]
[01:29:28.472]                   NAME <- NAMES[[kk]]
[01:29:28.472]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.472]                     next
[01:29:28.472]                   args[[name]] <- ""
[01:29:28.472]                 }
[01:29:28.472]                 NAMES <- toupper(removed)
[01:29:28.472]                 for (kk in seq_along(NAMES)) {
[01:29:28.472]                   name <- removed[[kk]]
[01:29:28.472]                   NAME <- NAMES[[kk]]
[01:29:28.472]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.472]                     next
[01:29:28.472]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.472]                 }
[01:29:28.472]                 if (length(args) > 0) 
[01:29:28.472]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.472]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.472]             }
[01:29:28.472]             else {
[01:29:28.472]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.472]             }
[01:29:28.472]             {
[01:29:28.472]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.472]                   0L) {
[01:29:28.472]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.472]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.472]                   base::options(opts)
[01:29:28.472]                 }
[01:29:28.472]                 {
[01:29:28.472]                   {
[01:29:28.472]                     base::assign(".Random.seed", c(10407L, 1745775247L, 
[01:29:28.472]                     -1336239575L, -260646334L, 1509109739L, -435616600L, 
[01:29:28.472]                     733352678L), envir = base::globalenv(), inherits = FALSE)
[01:29:28.472]                     NULL
[01:29:28.472]                   }
[01:29:28.472]                   options(future.plan = NULL)
[01:29:28.472]                   if (is.na(NA_character_)) 
[01:29:28.472]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.472]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.472]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.472]                   {
[01:29:28.472]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.472]                     if (!future$lazy) 
[01:29:28.472]                       future <- run(future)
[01:29:28.472]                     invisible(future)
[01:29:28.472]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.472]                 }
[01:29:28.472]             }
[01:29:28.472]         }
[01:29:28.472]     })
[01:29:28.472]     if (TRUE) {
[01:29:28.472]         base::sink(type = "output", split = FALSE)
[01:29:28.472]         if (TRUE) {
[01:29:28.472]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.472]         }
[01:29:28.472]         else {
[01:29:28.472]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.472]         }
[01:29:28.472]         base::close(...future.stdout)
[01:29:28.472]         ...future.stdout <- NULL
[01:29:28.472]     }
[01:29:28.472]     ...future.result$conditions <- ...future.conditions
[01:29:28.472]     ...future.result$finished <- base::Sys.time()
[01:29:28.472]     ...future.result
[01:29:28.472] }
[01:29:28.476] assign_globals() ...
[01:29:28.476] List of 1
[01:29:28.476]  $ x: int [1:4] 0 1 2 3
[01:29:28.476]  - attr(*, "where")=List of 1
[01:29:28.476]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.476]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.476]  - attr(*, "resolved")= logi FALSE
[01:29:28.476]  - attr(*, "total_size")= num 64
[01:29:28.476]  - attr(*, "already-done")= logi TRUE
[01:29:28.480] - copied 'x' to environment
[01:29:28.480] assign_globals() ... done
[01:29:28.480] plan(): Setting new future strategy stack:
[01:29:28.480] List of future strategies:
[01:29:28.480] 1. sequential:
[01:29:28.480]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.480]    - tweaked: FALSE
[01:29:28.480]    - call: NULL
[01:29:28.481] plan(): nbrOfWorkers() = 1
[01:29:28.482] plan(): Setting new future strategy stack:
[01:29:28.482] List of future strategies:
[01:29:28.482] 1. sequential:
[01:29:28.482]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.482]    - tweaked: FALSE
[01:29:28.482]    - call: plan(strategy)
[01:29:28.483] plan(): nbrOfWorkers() = 1
[01:29:28.483] SequentialFuture started (and completed)
[01:29:28.484] - Launch lazy future ... done
[01:29:28.484] run() for 'SequentialFuture' ... done
[01:29:28.484] Future state: 'finished'
[01:29:28.485] signalConditions() ...
[01:29:28.485]  - include = 'condition'
[01:29:28.485]  - exclude = 'immediateCondition'
[01:29:28.485]  - resignal = TRUE
[01:29:28.485]  - Number of conditions: 1
[01:29:28.486]  - Condition #1: 'RngFutureError', 'FutureError', 'error', 'RngFutureCondition', 'FutureCondition', 'condition'
[01:29:28.486] signalConditions() ... done
<RngFutureError: UNRELIABLE VALUE: Future ('fsample_1-249481') unexpectedly generated random numbers without specifying argument 'seed'. There is a risk that those random numbers are not statistically sound and the overall results might be invalid. To fix this, specify 'seed=TRUE'. This ensures that proper, parallel-safe random numbers are produced via the L'Ecuyer-CMRG method. To disable this check, use 'seed=NULL', or set option 'future.rng.onMisuse' to "ignore".>


Future UUID: b1bd9b86-ef45-d831-78f9-c00e789842f9


DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
SequentialFuture:
Label: 'fsample_1-249481'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001b96aeaa928
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Conditions captured: [n=1] 'RngFutureError'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'

DEBUG: END TROUBLESHOOTING HELP
[01:29:28.490] getGlobalsAndPackages() ...
[01:29:28.490] Searching for globals...
[01:29:28.491] - globals found: [3] '{', 'sample', 'x'
[01:29:28.491] Searching for globals ... DONE
[01:29:28.492] Resolving globals: FALSE
[01:29:28.492] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.493] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.493] - globals: [1] 'x'
[01:29:28.493] 
[01:29:28.493] getGlobalsAndPackages() ... DONE
[01:29:28.494] run() for 'Future' ...
[01:29:28.494] - state: 'created'
[01:29:28.494] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.495] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.495] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.495]   - Field: 'label'
[01:29:28.495]   - Field: 'local'
[01:29:28.495]   - Field: 'owner'
[01:29:28.496]   - Field: 'envir'
[01:29:28.496]   - Field: 'packages'
[01:29:28.496]   - Field: 'gc'
[01:29:28.496]   - Field: 'conditions'
[01:29:28.496]   - Field: 'expr'
[01:29:28.497]   - Field: 'uuid'
[01:29:28.497]   - Field: 'seed'
[01:29:28.497]   - Field: 'version'
[01:29:28.497]   - Field: 'result'
[01:29:28.497]   - Field: 'asynchronous'
[01:29:28.498]   - Field: 'calls'
[01:29:28.498]   - Field: 'globals'
[01:29:28.498]   - Field: 'stdout'
[01:29:28.498]   - Field: 'earlySignal'
[01:29:28.498]   - Field: 'lazy'
[01:29:28.499]   - Field: 'state'
[01:29:28.499] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.499] - Launch lazy future ...
[01:29:28.499] Packages needed by the future expression (n = 0): <none>
[01:29:28.499] Packages needed by future strategies (n = 0): <none>
[01:29:28.500] {
[01:29:28.500]     {
[01:29:28.500]         {
[01:29:28.500]             ...future.startTime <- base::Sys.time()
[01:29:28.500]             {
[01:29:28.500]                 {
[01:29:28.500]                   {
[01:29:28.500]                     base::local({
[01:29:28.500]                       has_future <- base::requireNamespace("future", 
[01:29:28.500]                         quietly = TRUE)
[01:29:28.500]                       if (has_future) {
[01:29:28.500]                         ns <- base::getNamespace("future")
[01:29:28.500]                         version <- ns[[".package"]][["version"]]
[01:29:28.500]                         if (is.null(version)) 
[01:29:28.500]                           version <- utils::packageVersion("future")
[01:29:28.500]                       }
[01:29:28.500]                       else {
[01:29:28.500]                         version <- NULL
[01:29:28.500]                       }
[01:29:28.500]                       if (!has_future || version < "1.8.0") {
[01:29:28.500]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.500]                           "", base::R.version$version.string), 
[01:29:28.500]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.500]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.500]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.500]                             "release", "version")], collapse = " "), 
[01:29:28.500]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.500]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.500]                           info)
[01:29:28.500]                         info <- base::paste(info, collapse = "; ")
[01:29:28.500]                         if (!has_future) {
[01:29:28.500]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.500]                             info)
[01:29:28.500]                         }
[01:29:28.500]                         else {
[01:29:28.500]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.500]                             info, version)
[01:29:28.500]                         }
[01:29:28.500]                         base::stop(msg)
[01:29:28.500]                       }
[01:29:28.500]                     })
[01:29:28.500]                   }
[01:29:28.500]                   options(future.plan = NULL)
[01:29:28.500]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.500]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.500]                 }
[01:29:28.500]                 ...future.workdir <- getwd()
[01:29:28.500]             }
[01:29:28.500]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.500]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.500]         }
[01:29:28.500]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.500]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.500]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.500]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.500]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.500]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.500]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.500]             base::names(...future.oldOptions))
[01:29:28.500]     }
[01:29:28.500]     if (FALSE) {
[01:29:28.500]     }
[01:29:28.500]     else {
[01:29:28.500]         if (TRUE) {
[01:29:28.500]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.500]                 open = "w")
[01:29:28.500]         }
[01:29:28.500]         else {
[01:29:28.500]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.500]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.500]         }
[01:29:28.500]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.500]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.500]             base::sink(type = "output", split = FALSE)
[01:29:28.500]             base::close(...future.stdout)
[01:29:28.500]         }, add = TRUE)
[01:29:28.500]     }
[01:29:28.500]     ...future.frame <- base::sys.nframe()
[01:29:28.500]     ...future.conditions <- base::list()
[01:29:28.500]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.500]     if (FALSE) {
[01:29:28.500]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.500]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.500]     }
[01:29:28.500]     ...future.result <- base::tryCatch({
[01:29:28.500]         base::withCallingHandlers({
[01:29:28.500]             ...future.value <- base::withVisible(base::local({
[01:29:28.500]                 sample(x, size = 1L)
[01:29:28.500]             }))
[01:29:28.500]             future::FutureResult(value = ...future.value$value, 
[01:29:28.500]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.500]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.500]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.500]                     ...future.globalenv.names))
[01:29:28.500]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.500]         }, condition = base::local({
[01:29:28.500]             c <- base::c
[01:29:28.500]             inherits <- base::inherits
[01:29:28.500]             invokeRestart <- base::invokeRestart
[01:29:28.500]             length <- base::length
[01:29:28.500]             list <- base::list
[01:29:28.500]             seq.int <- base::seq.int
[01:29:28.500]             signalCondition <- base::signalCondition
[01:29:28.500]             sys.calls <- base::sys.calls
[01:29:28.500]             `[[` <- base::`[[`
[01:29:28.500]             `+` <- base::`+`
[01:29:28.500]             `<<-` <- base::`<<-`
[01:29:28.500]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.500]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.500]                   3L)]
[01:29:28.500]             }
[01:29:28.500]             function(cond) {
[01:29:28.500]                 is_error <- inherits(cond, "error")
[01:29:28.500]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.500]                   NULL)
[01:29:28.500]                 if (is_error) {
[01:29:28.500]                   sessionInformation <- function() {
[01:29:28.500]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.500]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.500]                       search = base::search(), system = base::Sys.info())
[01:29:28.500]                   }
[01:29:28.500]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.500]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.500]                     cond$call), session = sessionInformation(), 
[01:29:28.500]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.500]                   signalCondition(cond)
[01:29:28.500]                 }
[01:29:28.500]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.500]                 "immediateCondition"))) {
[01:29:28.500]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.500]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.500]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.500]                   if (TRUE && !signal) {
[01:29:28.500]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.500]                     {
[01:29:28.500]                       inherits <- base::inherits
[01:29:28.500]                       invokeRestart <- base::invokeRestart
[01:29:28.500]                       is.null <- base::is.null
[01:29:28.500]                       muffled <- FALSE
[01:29:28.500]                       if (inherits(cond, "message")) {
[01:29:28.500]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.500]                         if (muffled) 
[01:29:28.500]                           invokeRestart("muffleMessage")
[01:29:28.500]                       }
[01:29:28.500]                       else if (inherits(cond, "warning")) {
[01:29:28.500]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.500]                         if (muffled) 
[01:29:28.500]                           invokeRestart("muffleWarning")
[01:29:28.500]                       }
[01:29:28.500]                       else if (inherits(cond, "condition")) {
[01:29:28.500]                         if (!is.null(pattern)) {
[01:29:28.500]                           computeRestarts <- base::computeRestarts
[01:29:28.500]                           grepl <- base::grepl
[01:29:28.500]                           restarts <- computeRestarts(cond)
[01:29:28.500]                           for (restart in restarts) {
[01:29:28.500]                             name <- restart$name
[01:29:28.500]                             if (is.null(name)) 
[01:29:28.500]                               next
[01:29:28.500]                             if (!grepl(pattern, name)) 
[01:29:28.500]                               next
[01:29:28.500]                             invokeRestart(restart)
[01:29:28.500]                             muffled <- TRUE
[01:29:28.500]                             break
[01:29:28.500]                           }
[01:29:28.500]                         }
[01:29:28.500]                       }
[01:29:28.500]                       invisible(muffled)
[01:29:28.500]                     }
[01:29:28.500]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.500]                   }
[01:29:28.500]                 }
[01:29:28.500]                 else {
[01:29:28.500]                   if (TRUE) {
[01:29:28.500]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.500]                     {
[01:29:28.500]                       inherits <- base::inherits
[01:29:28.500]                       invokeRestart <- base::invokeRestart
[01:29:28.500]                       is.null <- base::is.null
[01:29:28.500]                       muffled <- FALSE
[01:29:28.500]                       if (inherits(cond, "message")) {
[01:29:28.500]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.500]                         if (muffled) 
[01:29:28.500]                           invokeRestart("muffleMessage")
[01:29:28.500]                       }
[01:29:28.500]                       else if (inherits(cond, "warning")) {
[01:29:28.500]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.500]                         if (muffled) 
[01:29:28.500]                           invokeRestart("muffleWarning")
[01:29:28.500]                       }
[01:29:28.500]                       else if (inherits(cond, "condition")) {
[01:29:28.500]                         if (!is.null(pattern)) {
[01:29:28.500]                           computeRestarts <- base::computeRestarts
[01:29:28.500]                           grepl <- base::grepl
[01:29:28.500]                           restarts <- computeRestarts(cond)
[01:29:28.500]                           for (restart in restarts) {
[01:29:28.500]                             name <- restart$name
[01:29:28.500]                             if (is.null(name)) 
[01:29:28.500]                               next
[01:29:28.500]                             if (!grepl(pattern, name)) 
[01:29:28.500]                               next
[01:29:28.500]                             invokeRestart(restart)
[01:29:28.500]                             muffled <- TRUE
[01:29:28.500]                             break
[01:29:28.500]                           }
[01:29:28.500]                         }
[01:29:28.500]                       }
[01:29:28.500]                       invisible(muffled)
[01:29:28.500]                     }
[01:29:28.500]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.500]                   }
[01:29:28.500]                 }
[01:29:28.500]             }
[01:29:28.500]         }))
[01:29:28.500]     }, error = function(ex) {
[01:29:28.500]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.500]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.500]                 ...future.rng), started = ...future.startTime, 
[01:29:28.500]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.500]             version = "1.8"), class = "FutureResult")
[01:29:28.500]     }, finally = {
[01:29:28.500]         if (!identical(...future.workdir, getwd())) 
[01:29:28.500]             setwd(...future.workdir)
[01:29:28.500]         {
[01:29:28.500]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.500]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.500]             }
[01:29:28.500]             base::options(...future.oldOptions)
[01:29:28.500]             if (.Platform$OS.type == "windows") {
[01:29:28.500]                 old_names <- names(...future.oldEnvVars)
[01:29:28.500]                 envs <- base::Sys.getenv()
[01:29:28.500]                 names <- names(envs)
[01:29:28.500]                 common <- intersect(names, old_names)
[01:29:28.500]                 added <- setdiff(names, old_names)
[01:29:28.500]                 removed <- setdiff(old_names, names)
[01:29:28.500]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.500]                   envs[common]]
[01:29:28.500]                 NAMES <- toupper(changed)
[01:29:28.500]                 args <- list()
[01:29:28.500]                 for (kk in seq_along(NAMES)) {
[01:29:28.500]                   name <- changed[[kk]]
[01:29:28.500]                   NAME <- NAMES[[kk]]
[01:29:28.500]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.500]                     next
[01:29:28.500]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.500]                 }
[01:29:28.500]                 NAMES <- toupper(added)
[01:29:28.500]                 for (kk in seq_along(NAMES)) {
[01:29:28.500]                   name <- added[[kk]]
[01:29:28.500]                   NAME <- NAMES[[kk]]
[01:29:28.500]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.500]                     next
[01:29:28.500]                   args[[name]] <- ""
[01:29:28.500]                 }
[01:29:28.500]                 NAMES <- toupper(removed)
[01:29:28.500]                 for (kk in seq_along(NAMES)) {
[01:29:28.500]                   name <- removed[[kk]]
[01:29:28.500]                   NAME <- NAMES[[kk]]
[01:29:28.500]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.500]                     next
[01:29:28.500]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.500]                 }
[01:29:28.500]                 if (length(args) > 0) 
[01:29:28.500]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.500]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.500]             }
[01:29:28.500]             else {
[01:29:28.500]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.500]             }
[01:29:28.500]             {
[01:29:28.500]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.500]                   0L) {
[01:29:28.500]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.500]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.500]                   base::options(opts)
[01:29:28.500]                 }
[01:29:28.500]                 {
[01:29:28.500]                   {
[01:29:28.500]                     base::assign(".Random.seed", c(10407L, -1638694753L, 
[01:29:28.500]                     -1322645656L, -464764483L, 1355433907L, -877075751L, 
[01:29:28.500]                     1602385273L), envir = base::globalenv(), 
[01:29:28.500]                       inherits = FALSE)
[01:29:28.500]                     NULL
[01:29:28.500]                   }
[01:29:28.500]                   options(future.plan = NULL)
[01:29:28.500]                   if (is.na(NA_character_)) 
[01:29:28.500]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.500]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.500]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.500]                   {
[01:29:28.500]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.500]                     if (!future$lazy) 
[01:29:28.500]                       future <- run(future)
[01:29:28.500]                     invisible(future)
[01:29:28.500]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.500]                 }
[01:29:28.500]             }
[01:29:28.500]         }
[01:29:28.500]     })
[01:29:28.500]     if (TRUE) {
[01:29:28.500]         base::sink(type = "output", split = FALSE)
[01:29:28.500]         if (TRUE) {
[01:29:28.500]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.500]         }
[01:29:28.500]         else {
[01:29:28.500]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.500]         }
[01:29:28.500]         base::close(...future.stdout)
[01:29:28.500]         ...future.stdout <- NULL
[01:29:28.500]     }
[01:29:28.500]     ...future.result$conditions <- ...future.conditions
[01:29:28.500]     ...future.result$finished <- base::Sys.time()
[01:29:28.500]     ...future.result
[01:29:28.500] }
[01:29:28.504] assign_globals() ...
[01:29:28.504] List of 1
[01:29:28.504]  $ x: int [1:4] 0 1 2 3
[01:29:28.504]  - attr(*, "where")=List of 1
[01:29:28.504]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.504]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.504]  - attr(*, "resolved")= logi FALSE
[01:29:28.504]  - attr(*, "total_size")= num 64
[01:29:28.504]  - attr(*, "already-done")= logi TRUE
[01:29:28.507] - copied 'x' to environment
[01:29:28.507] assign_globals() ... done
[01:29:28.508] plan(): Setting new future strategy stack:
[01:29:28.508] List of future strategies:
[01:29:28.508] 1. sequential:
[01:29:28.508]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.508]    - tweaked: FALSE
[01:29:28.508]    - call: NULL
[01:29:28.509] plan(): nbrOfWorkers() = 1
[01:29:28.510] plan(): Setting new future strategy stack:
[01:29:28.510] List of future strategies:
[01:29:28.510] 1. sequential:
[01:29:28.510]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.510]    - tweaked: FALSE
[01:29:28.510]    - call: plan(strategy)
[01:29:28.511] plan(): nbrOfWorkers() = 1
[01:29:28.511] SequentialFuture started (and completed)
[01:29:28.511] - Launch lazy future ... done
[01:29:28.512] run() for 'SequentialFuture' ... done
[01:29:28.512] getGlobalsAndPackages() ...
[01:29:28.513] Searching for globals...
[01:29:28.514] - globals found: [3] '{', 'sample', 'x'
[01:29:28.514] Searching for globals ... DONE
[01:29:28.514] Resolving globals: FALSE
[01:29:28.515] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.515] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.515] - globals: [1] 'x'
[01:29:28.516] 
[01:29:28.516] getGlobalsAndPackages() ... DONE
[01:29:28.516] run() for 'Future' ...
[01:29:28.516] - state: 'created'
[01:29:28.517] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.517] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.517] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.517]   - Field: 'label'
[01:29:28.518]   - Field: 'local'
[01:29:28.518]   - Field: 'owner'
[01:29:28.519]   - Field: 'envir'
[01:29:28.519]   - Field: 'packages'
[01:29:28.519]   - Field: 'gc'
[01:29:28.520]   - Field: 'conditions'
[01:29:28.520]   - Field: 'expr'
[01:29:28.520]   - Field: 'uuid'
[01:29:28.520]   - Field: 'seed'
[01:29:28.525]   - Field: 'version'
[01:29:28.526]   - Field: 'result'
[01:29:28.526]   - Field: 'asynchronous'
[01:29:28.526]   - Field: 'calls'
[01:29:28.527]   - Field: 'globals'
[01:29:28.527]   - Field: 'stdout'
[01:29:28.527]   - Field: 'earlySignal'
[01:29:28.528]   - Field: 'lazy'
[01:29:28.528]   - Field: 'state'
[01:29:28.528] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.529] - Launch lazy future ...
[01:29:28.529] Packages needed by the future expression (n = 0): <none>
[01:29:28.530] Packages needed by future strategies (n = 0): <none>
[01:29:28.531] {
[01:29:28.531]     {
[01:29:28.531]         {
[01:29:28.531]             ...future.startTime <- base::Sys.time()
[01:29:28.531]             {
[01:29:28.531]                 {
[01:29:28.531]                   {
[01:29:28.531]                     base::local({
[01:29:28.531]                       has_future <- base::requireNamespace("future", 
[01:29:28.531]                         quietly = TRUE)
[01:29:28.531]                       if (has_future) {
[01:29:28.531]                         ns <- base::getNamespace("future")
[01:29:28.531]                         version <- ns[[".package"]][["version"]]
[01:29:28.531]                         if (is.null(version)) 
[01:29:28.531]                           version <- utils::packageVersion("future")
[01:29:28.531]                       }
[01:29:28.531]                       else {
[01:29:28.531]                         version <- NULL
[01:29:28.531]                       }
[01:29:28.531]                       if (!has_future || version < "1.8.0") {
[01:29:28.531]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.531]                           "", base::R.version$version.string), 
[01:29:28.531]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.531]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.531]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.531]                             "release", "version")], collapse = " "), 
[01:29:28.531]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.531]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.531]                           info)
[01:29:28.531]                         info <- base::paste(info, collapse = "; ")
[01:29:28.531]                         if (!has_future) {
[01:29:28.531]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.531]                             info)
[01:29:28.531]                         }
[01:29:28.531]                         else {
[01:29:28.531]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.531]                             info, version)
[01:29:28.531]                         }
[01:29:28.531]                         base::stop(msg)
[01:29:28.531]                       }
[01:29:28.531]                     })
[01:29:28.531]                   }
[01:29:28.531]                   options(future.plan = NULL)
[01:29:28.531]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.531]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.531]                 }
[01:29:28.531]                 ...future.workdir <- getwd()
[01:29:28.531]             }
[01:29:28.531]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.531]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.531]         }
[01:29:28.531]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.531]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.531]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.531]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.531]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.531]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.531]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.531]             base::names(...future.oldOptions))
[01:29:28.531]     }
[01:29:28.531]     if (FALSE) {
[01:29:28.531]     }
[01:29:28.531]     else {
[01:29:28.531]         if (TRUE) {
[01:29:28.531]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.531]                 open = "w")
[01:29:28.531]         }
[01:29:28.531]         else {
[01:29:28.531]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.531]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.531]         }
[01:29:28.531]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.531]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.531]             base::sink(type = "output", split = FALSE)
[01:29:28.531]             base::close(...future.stdout)
[01:29:28.531]         }, add = TRUE)
[01:29:28.531]     }
[01:29:28.531]     ...future.frame <- base::sys.nframe()
[01:29:28.531]     ...future.conditions <- base::list()
[01:29:28.531]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.531]     if (FALSE) {
[01:29:28.531]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.531]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.531]     }
[01:29:28.531]     ...future.result <- base::tryCatch({
[01:29:28.531]         base::withCallingHandlers({
[01:29:28.531]             ...future.value <- base::withVisible(base::local({
[01:29:28.531]                 sample(x, size = 1L)
[01:29:28.531]             }))
[01:29:28.531]             future::FutureResult(value = ...future.value$value, 
[01:29:28.531]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.531]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.531]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.531]                     ...future.globalenv.names))
[01:29:28.531]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.531]         }, condition = base::local({
[01:29:28.531]             c <- base::c
[01:29:28.531]             inherits <- base::inherits
[01:29:28.531]             invokeRestart <- base::invokeRestart
[01:29:28.531]             length <- base::length
[01:29:28.531]             list <- base::list
[01:29:28.531]             seq.int <- base::seq.int
[01:29:28.531]             signalCondition <- base::signalCondition
[01:29:28.531]             sys.calls <- base::sys.calls
[01:29:28.531]             `[[` <- base::`[[`
[01:29:28.531]             `+` <- base::`+`
[01:29:28.531]             `<<-` <- base::`<<-`
[01:29:28.531]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.531]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.531]                   3L)]
[01:29:28.531]             }
[01:29:28.531]             function(cond) {
[01:29:28.531]                 is_error <- inherits(cond, "error")
[01:29:28.531]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.531]                   NULL)
[01:29:28.531]                 if (is_error) {
[01:29:28.531]                   sessionInformation <- function() {
[01:29:28.531]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.531]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.531]                       search = base::search(), system = base::Sys.info())
[01:29:28.531]                   }
[01:29:28.531]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.531]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.531]                     cond$call), session = sessionInformation(), 
[01:29:28.531]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.531]                   signalCondition(cond)
[01:29:28.531]                 }
[01:29:28.531]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.531]                 "immediateCondition"))) {
[01:29:28.531]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.531]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.531]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.531]                   if (TRUE && !signal) {
[01:29:28.531]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.531]                     {
[01:29:28.531]                       inherits <- base::inherits
[01:29:28.531]                       invokeRestart <- base::invokeRestart
[01:29:28.531]                       is.null <- base::is.null
[01:29:28.531]                       muffled <- FALSE
[01:29:28.531]                       if (inherits(cond, "message")) {
[01:29:28.531]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.531]                         if (muffled) 
[01:29:28.531]                           invokeRestart("muffleMessage")
[01:29:28.531]                       }
[01:29:28.531]                       else if (inherits(cond, "warning")) {
[01:29:28.531]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.531]                         if (muffled) 
[01:29:28.531]                           invokeRestart("muffleWarning")
[01:29:28.531]                       }
[01:29:28.531]                       else if (inherits(cond, "condition")) {
[01:29:28.531]                         if (!is.null(pattern)) {
[01:29:28.531]                           computeRestarts <- base::computeRestarts
[01:29:28.531]                           grepl <- base::grepl
[01:29:28.531]                           restarts <- computeRestarts(cond)
[01:29:28.531]                           for (restart in restarts) {
[01:29:28.531]                             name <- restart$name
[01:29:28.531]                             if (is.null(name)) 
[01:29:28.531]                               next
[01:29:28.531]                             if (!grepl(pattern, name)) 
[01:29:28.531]                               next
[01:29:28.531]                             invokeRestart(restart)
[01:29:28.531]                             muffled <- TRUE
[01:29:28.531]                             break
[01:29:28.531]                           }
[01:29:28.531]                         }
[01:29:28.531]                       }
[01:29:28.531]                       invisible(muffled)
[01:29:28.531]                     }
[01:29:28.531]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.531]                   }
[01:29:28.531]                 }
[01:29:28.531]                 else {
[01:29:28.531]                   if (TRUE) {
[01:29:28.531]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.531]                     {
[01:29:28.531]                       inherits <- base::inherits
[01:29:28.531]                       invokeRestart <- base::invokeRestart
[01:29:28.531]                       is.null <- base::is.null
[01:29:28.531]                       muffled <- FALSE
[01:29:28.531]                       if (inherits(cond, "message")) {
[01:29:28.531]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.531]                         if (muffled) 
[01:29:28.531]                           invokeRestart("muffleMessage")
[01:29:28.531]                       }
[01:29:28.531]                       else if (inherits(cond, "warning")) {
[01:29:28.531]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.531]                         if (muffled) 
[01:29:28.531]                           invokeRestart("muffleWarning")
[01:29:28.531]                       }
[01:29:28.531]                       else if (inherits(cond, "condition")) {
[01:29:28.531]                         if (!is.null(pattern)) {
[01:29:28.531]                           computeRestarts <- base::computeRestarts
[01:29:28.531]                           grepl <- base::grepl
[01:29:28.531]                           restarts <- computeRestarts(cond)
[01:29:28.531]                           for (restart in restarts) {
[01:29:28.531]                             name <- restart$name
[01:29:28.531]                             if (is.null(name)) 
[01:29:28.531]                               next
[01:29:28.531]                             if (!grepl(pattern, name)) 
[01:29:28.531]                               next
[01:29:28.531]                             invokeRestart(restart)
[01:29:28.531]                             muffled <- TRUE
[01:29:28.531]                             break
[01:29:28.531]                           }
[01:29:28.531]                         }
[01:29:28.531]                       }
[01:29:28.531]                       invisible(muffled)
[01:29:28.531]                     }
[01:29:28.531]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.531]                   }
[01:29:28.531]                 }
[01:29:28.531]             }
[01:29:28.531]         }))
[01:29:28.531]     }, error = function(ex) {
[01:29:28.531]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.531]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.531]                 ...future.rng), started = ...future.startTime, 
[01:29:28.531]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.531]             version = "1.8"), class = "FutureResult")
[01:29:28.531]     }, finally = {
[01:29:28.531]         if (!identical(...future.workdir, getwd())) 
[01:29:28.531]             setwd(...future.workdir)
[01:29:28.531]         {
[01:29:28.531]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.531]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.531]             }
[01:29:28.531]             base::options(...future.oldOptions)
[01:29:28.531]             if (.Platform$OS.type == "windows") {
[01:29:28.531]                 old_names <- names(...future.oldEnvVars)
[01:29:28.531]                 envs <- base::Sys.getenv()
[01:29:28.531]                 names <- names(envs)
[01:29:28.531]                 common <- intersect(names, old_names)
[01:29:28.531]                 added <- setdiff(names, old_names)
[01:29:28.531]                 removed <- setdiff(old_names, names)
[01:29:28.531]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.531]                   envs[common]]
[01:29:28.531]                 NAMES <- toupper(changed)
[01:29:28.531]                 args <- list()
[01:29:28.531]                 for (kk in seq_along(NAMES)) {
[01:29:28.531]                   name <- changed[[kk]]
[01:29:28.531]                   NAME <- NAMES[[kk]]
[01:29:28.531]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.531]                     next
[01:29:28.531]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.531]                 }
[01:29:28.531]                 NAMES <- toupper(added)
[01:29:28.531]                 for (kk in seq_along(NAMES)) {
[01:29:28.531]                   name <- added[[kk]]
[01:29:28.531]                   NAME <- NAMES[[kk]]
[01:29:28.531]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.531]                     next
[01:29:28.531]                   args[[name]] <- ""
[01:29:28.531]                 }
[01:29:28.531]                 NAMES <- toupper(removed)
[01:29:28.531]                 for (kk in seq_along(NAMES)) {
[01:29:28.531]                   name <- removed[[kk]]
[01:29:28.531]                   NAME <- NAMES[[kk]]
[01:29:28.531]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.531]                     next
[01:29:28.531]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.531]                 }
[01:29:28.531]                 if (length(args) > 0) 
[01:29:28.531]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.531]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.531]             }
[01:29:28.531]             else {
[01:29:28.531]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.531]             }
[01:29:28.531]             {
[01:29:28.531]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.531]                   0L) {
[01:29:28.531]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.531]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.531]                   base::options(opts)
[01:29:28.531]                 }
[01:29:28.531]                 {
[01:29:28.531]                   {
[01:29:28.531]                     base::assign(".Random.seed", c(10407L, -464764483L, 
[01:29:28.531]                     -151635093L, 1386553462L, 1602385273L, 415878624L, 
[01:29:28.531]                     -450284196L), envir = base::globalenv(), 
[01:29:28.531]                       inherits = FALSE)
[01:29:28.531]                     NULL
[01:29:28.531]                   }
[01:29:28.531]                   options(future.plan = NULL)
[01:29:28.531]                   if (is.na(NA_character_)) 
[01:29:28.531]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.531]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.531]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.531]                   {
[01:29:28.531]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.531]                     if (!future$lazy) 
[01:29:28.531]                       future <- run(future)
[01:29:28.531]                     invisible(future)
[01:29:28.531]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.531]                 }
[01:29:28.531]             }
[01:29:28.531]         }
[01:29:28.531]     })
[01:29:28.531]     if (TRUE) {
[01:29:28.531]         base::sink(type = "output", split = FALSE)
[01:29:28.531]         if (TRUE) {
[01:29:28.531]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.531]         }
[01:29:28.531]         else {
[01:29:28.531]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.531]         }
[01:29:28.531]         base::close(...future.stdout)
[01:29:28.531]         ...future.stdout <- NULL
[01:29:28.531]     }
[01:29:28.531]     ...future.result$conditions <- ...future.conditions
[01:29:28.531]     ...future.result$finished <- base::Sys.time()
[01:29:28.531]     ...future.result
[01:29:28.531] }
[01:29:28.536] assign_globals() ...
[01:29:28.536] List of 1
[01:29:28.536]  $ x: int [1:4] 0 1 2 3
[01:29:28.536]  - attr(*, "where")=List of 1
[01:29:28.536]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.536]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.536]  - attr(*, "resolved")= logi FALSE
[01:29:28.536]  - attr(*, "total_size")= num 64
[01:29:28.536]  - attr(*, "already-done")= logi TRUE
[01:29:28.542] - copied 'x' to environment
[01:29:28.543] assign_globals() ... done
[01:29:28.543] plan(): Setting new future strategy stack:
[01:29:28.544] List of future strategies:
[01:29:28.544] 1. sequential:
[01:29:28.544]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.544]    - tweaked: FALSE
[01:29:28.544]    - call: NULL
[01:29:28.545] plan(): nbrOfWorkers() = 1
[01:29:28.547] plan(): Setting new future strategy stack:
[01:29:28.547] List of future strategies:
[01:29:28.547] 1. sequential:
[01:29:28.547]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.547]    - tweaked: FALSE
[01:29:28.547]    - call: plan(strategy)
[01:29:28.548] plan(): nbrOfWorkers() = 1
[01:29:28.548] SequentialFuture started (and completed)
[01:29:28.549] - Launch lazy future ... done
[01:29:28.549] run() for 'SequentialFuture' ... done
[01:29:28.550] getGlobalsAndPackages() ...
[01:29:28.550] Searching for globals...
[01:29:28.553] - globals found: [3] '{', 'sample', 'x'
[01:29:28.553] Searching for globals ... DONE
[01:29:28.553] Resolving globals: FALSE
[01:29:28.554] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.555] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.555] - globals: [1] 'x'
[01:29:28.555] 
[01:29:28.555] getGlobalsAndPackages() ... DONE
[01:29:28.556] run() for 'Future' ...
[01:29:28.556] - state: 'created'
[01:29:28.557] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.557] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.557] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.558]   - Field: 'label'
[01:29:28.558]   - Field: 'local'
[01:29:28.558]   - Field: 'owner'
[01:29:28.559]   - Field: 'envir'
[01:29:28.559]   - Field: 'packages'
[01:29:28.559]   - Field: 'gc'
[01:29:28.559]   - Field: 'conditions'
[01:29:28.560]   - Field: 'expr'
[01:29:28.560]   - Field: 'uuid'
[01:29:28.560]   - Field: 'seed'
[01:29:28.560]   - Field: 'version'
[01:29:28.561]   - Field: 'result'
[01:29:28.561]   - Field: 'asynchronous'
[01:29:28.561]   - Field: 'calls'
[01:29:28.562]   - Field: 'globals'
[01:29:28.562]   - Field: 'stdout'
[01:29:28.562]   - Field: 'earlySignal'
[01:29:28.562]   - Field: 'lazy'
[01:29:28.563]   - Field: 'state'
[01:29:28.563] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.563] - Launch lazy future ...
[01:29:28.564] Packages needed by the future expression (n = 0): <none>
[01:29:28.564] Packages needed by future strategies (n = 0): <none>
[01:29:28.565] {
[01:29:28.565]     {
[01:29:28.565]         {
[01:29:28.565]             ...future.startTime <- base::Sys.time()
[01:29:28.565]             {
[01:29:28.565]                 {
[01:29:28.565]                   {
[01:29:28.565]                     base::local({
[01:29:28.565]                       has_future <- base::requireNamespace("future", 
[01:29:28.565]                         quietly = TRUE)
[01:29:28.565]                       if (has_future) {
[01:29:28.565]                         ns <- base::getNamespace("future")
[01:29:28.565]                         version <- ns[[".package"]][["version"]]
[01:29:28.565]                         if (is.null(version)) 
[01:29:28.565]                           version <- utils::packageVersion("future")
[01:29:28.565]                       }
[01:29:28.565]                       else {
[01:29:28.565]                         version <- NULL
[01:29:28.565]                       }
[01:29:28.565]                       if (!has_future || version < "1.8.0") {
[01:29:28.565]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.565]                           "", base::R.version$version.string), 
[01:29:28.565]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.565]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.565]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.565]                             "release", "version")], collapse = " "), 
[01:29:28.565]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.565]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.565]                           info)
[01:29:28.565]                         info <- base::paste(info, collapse = "; ")
[01:29:28.565]                         if (!has_future) {
[01:29:28.565]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.565]                             info)
[01:29:28.565]                         }
[01:29:28.565]                         else {
[01:29:28.565]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.565]                             info, version)
[01:29:28.565]                         }
[01:29:28.565]                         base::stop(msg)
[01:29:28.565]                       }
[01:29:28.565]                     })
[01:29:28.565]                   }
[01:29:28.565]                   options(future.plan = NULL)
[01:29:28.565]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.565]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.565]                 }
[01:29:28.565]                 ...future.workdir <- getwd()
[01:29:28.565]             }
[01:29:28.565]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.565]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.565]         }
[01:29:28.565]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.565]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.565]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.565]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.565]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.565]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.565]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.565]             base::names(...future.oldOptions))
[01:29:28.565]     }
[01:29:28.565]     if (FALSE) {
[01:29:28.565]     }
[01:29:28.565]     else {
[01:29:28.565]         if (TRUE) {
[01:29:28.565]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.565]                 open = "w")
[01:29:28.565]         }
[01:29:28.565]         else {
[01:29:28.565]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.565]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.565]         }
[01:29:28.565]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.565]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.565]             base::sink(type = "output", split = FALSE)
[01:29:28.565]             base::close(...future.stdout)
[01:29:28.565]         }, add = TRUE)
[01:29:28.565]     }
[01:29:28.565]     ...future.frame <- base::sys.nframe()
[01:29:28.565]     ...future.conditions <- base::list()
[01:29:28.565]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.565]     if (FALSE) {
[01:29:28.565]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.565]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.565]     }
[01:29:28.565]     ...future.result <- base::tryCatch({
[01:29:28.565]         base::withCallingHandlers({
[01:29:28.565]             ...future.value <- base::withVisible(base::local({
[01:29:28.565]                 sample(x, size = 1L)
[01:29:28.565]             }))
[01:29:28.565]             future::FutureResult(value = ...future.value$value, 
[01:29:28.565]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.565]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.565]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.565]                     ...future.globalenv.names))
[01:29:28.565]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.565]         }, condition = base::local({
[01:29:28.565]             c <- base::c
[01:29:28.565]             inherits <- base::inherits
[01:29:28.565]             invokeRestart <- base::invokeRestart
[01:29:28.565]             length <- base::length
[01:29:28.565]             list <- base::list
[01:29:28.565]             seq.int <- base::seq.int
[01:29:28.565]             signalCondition <- base::signalCondition
[01:29:28.565]             sys.calls <- base::sys.calls
[01:29:28.565]             `[[` <- base::`[[`
[01:29:28.565]             `+` <- base::`+`
[01:29:28.565]             `<<-` <- base::`<<-`
[01:29:28.565]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.565]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.565]                   3L)]
[01:29:28.565]             }
[01:29:28.565]             function(cond) {
[01:29:28.565]                 is_error <- inherits(cond, "error")
[01:29:28.565]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.565]                   NULL)
[01:29:28.565]                 if (is_error) {
[01:29:28.565]                   sessionInformation <- function() {
[01:29:28.565]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.565]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.565]                       search = base::search(), system = base::Sys.info())
[01:29:28.565]                   }
[01:29:28.565]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.565]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.565]                     cond$call), session = sessionInformation(), 
[01:29:28.565]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.565]                   signalCondition(cond)
[01:29:28.565]                 }
[01:29:28.565]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.565]                 "immediateCondition"))) {
[01:29:28.565]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.565]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.565]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.565]                   if (TRUE && !signal) {
[01:29:28.565]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.565]                     {
[01:29:28.565]                       inherits <- base::inherits
[01:29:28.565]                       invokeRestart <- base::invokeRestart
[01:29:28.565]                       is.null <- base::is.null
[01:29:28.565]                       muffled <- FALSE
[01:29:28.565]                       if (inherits(cond, "message")) {
[01:29:28.565]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.565]                         if (muffled) 
[01:29:28.565]                           invokeRestart("muffleMessage")
[01:29:28.565]                       }
[01:29:28.565]                       else if (inherits(cond, "warning")) {
[01:29:28.565]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.565]                         if (muffled) 
[01:29:28.565]                           invokeRestart("muffleWarning")
[01:29:28.565]                       }
[01:29:28.565]                       else if (inherits(cond, "condition")) {
[01:29:28.565]                         if (!is.null(pattern)) {
[01:29:28.565]                           computeRestarts <- base::computeRestarts
[01:29:28.565]                           grepl <- base::grepl
[01:29:28.565]                           restarts <- computeRestarts(cond)
[01:29:28.565]                           for (restart in restarts) {
[01:29:28.565]                             name <- restart$name
[01:29:28.565]                             if (is.null(name)) 
[01:29:28.565]                               next
[01:29:28.565]                             if (!grepl(pattern, name)) 
[01:29:28.565]                               next
[01:29:28.565]                             invokeRestart(restart)
[01:29:28.565]                             muffled <- TRUE
[01:29:28.565]                             break
[01:29:28.565]                           }
[01:29:28.565]                         }
[01:29:28.565]                       }
[01:29:28.565]                       invisible(muffled)
[01:29:28.565]                     }
[01:29:28.565]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.565]                   }
[01:29:28.565]                 }
[01:29:28.565]                 else {
[01:29:28.565]                   if (TRUE) {
[01:29:28.565]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.565]                     {
[01:29:28.565]                       inherits <- base::inherits
[01:29:28.565]                       invokeRestart <- base::invokeRestart
[01:29:28.565]                       is.null <- base::is.null
[01:29:28.565]                       muffled <- FALSE
[01:29:28.565]                       if (inherits(cond, "message")) {
[01:29:28.565]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.565]                         if (muffled) 
[01:29:28.565]                           invokeRestart("muffleMessage")
[01:29:28.565]                       }
[01:29:28.565]                       else if (inherits(cond, "warning")) {
[01:29:28.565]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.565]                         if (muffled) 
[01:29:28.565]                           invokeRestart("muffleWarning")
[01:29:28.565]                       }
[01:29:28.565]                       else if (inherits(cond, "condition")) {
[01:29:28.565]                         if (!is.null(pattern)) {
[01:29:28.565]                           computeRestarts <- base::computeRestarts
[01:29:28.565]                           grepl <- base::grepl
[01:29:28.565]                           restarts <- computeRestarts(cond)
[01:29:28.565]                           for (restart in restarts) {
[01:29:28.565]                             name <- restart$name
[01:29:28.565]                             if (is.null(name)) 
[01:29:28.565]                               next
[01:29:28.565]                             if (!grepl(pattern, name)) 
[01:29:28.565]                               next
[01:29:28.565]                             invokeRestart(restart)
[01:29:28.565]                             muffled <- TRUE
[01:29:28.565]                             break
[01:29:28.565]                           }
[01:29:28.565]                         }
[01:29:28.565]                       }
[01:29:28.565]                       invisible(muffled)
[01:29:28.565]                     }
[01:29:28.565]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.565]                   }
[01:29:28.565]                 }
[01:29:28.565]             }
[01:29:28.565]         }))
[01:29:28.565]     }, error = function(ex) {
[01:29:28.565]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.565]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.565]                 ...future.rng), started = ...future.startTime, 
[01:29:28.565]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.565]             version = "1.8"), class = "FutureResult")
[01:29:28.565]     }, finally = {
[01:29:28.565]         if (!identical(...future.workdir, getwd())) 
[01:29:28.565]             setwd(...future.workdir)
[01:29:28.565]         {
[01:29:28.565]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.565]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.565]             }
[01:29:28.565]             base::options(...future.oldOptions)
[01:29:28.565]             if (.Platform$OS.type == "windows") {
[01:29:28.565]                 old_names <- names(...future.oldEnvVars)
[01:29:28.565]                 envs <- base::Sys.getenv()
[01:29:28.565]                 names <- names(envs)
[01:29:28.565]                 common <- intersect(names, old_names)
[01:29:28.565]                 added <- setdiff(names, old_names)
[01:29:28.565]                 removed <- setdiff(old_names, names)
[01:29:28.565]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.565]                   envs[common]]
[01:29:28.565]                 NAMES <- toupper(changed)
[01:29:28.565]                 args <- list()
[01:29:28.565]                 for (kk in seq_along(NAMES)) {
[01:29:28.565]                   name <- changed[[kk]]
[01:29:28.565]                   NAME <- NAMES[[kk]]
[01:29:28.565]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.565]                     next
[01:29:28.565]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.565]                 }
[01:29:28.565]                 NAMES <- toupper(added)
[01:29:28.565]                 for (kk in seq_along(NAMES)) {
[01:29:28.565]                   name <- added[[kk]]
[01:29:28.565]                   NAME <- NAMES[[kk]]
[01:29:28.565]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.565]                     next
[01:29:28.565]                   args[[name]] <- ""
[01:29:28.565]                 }
[01:29:28.565]                 NAMES <- toupper(removed)
[01:29:28.565]                 for (kk in seq_along(NAMES)) {
[01:29:28.565]                   name <- removed[[kk]]
[01:29:28.565]                   NAME <- NAMES[[kk]]
[01:29:28.565]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.565]                     next
[01:29:28.565]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.565]                 }
[01:29:28.565]                 if (length(args) > 0) 
[01:29:28.565]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.565]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.565]             }
[01:29:28.565]             else {
[01:29:28.565]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.565]             }
[01:29:28.565]             {
[01:29:28.565]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.565]                   0L) {
[01:29:28.565]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.565]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.565]                   base::options(opts)
[01:29:28.565]                 }
[01:29:28.565]                 {
[01:29:28.565]                   {
[01:29:28.565]                     base::assign(".Random.seed", c(10407L, 1386553462L, 
[01:29:28.565]                     1056333440L, -1269930425L, -450284196L, -1698591186L, 
[01:29:28.565]                     -1338438503L), envir = base::globalenv(), 
[01:29:28.565]                       inherits = FALSE)
[01:29:28.565]                     NULL
[01:29:28.565]                   }
[01:29:28.565]                   options(future.plan = NULL)
[01:29:28.565]                   if (is.na(NA_character_)) 
[01:29:28.565]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.565]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.565]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.565]                   {
[01:29:28.565]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.565]                     if (!future$lazy) 
[01:29:28.565]                       future <- run(future)
[01:29:28.565]                     invisible(future)
[01:29:28.565]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.565]                 }
[01:29:28.565]             }
[01:29:28.565]         }
[01:29:28.565]     })
[01:29:28.565]     if (TRUE) {
[01:29:28.565]         base::sink(type = "output", split = FALSE)
[01:29:28.565]         if (TRUE) {
[01:29:28.565]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.565]         }
[01:29:28.565]         else {
[01:29:28.565]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.565]         }
[01:29:28.565]         base::close(...future.stdout)
[01:29:28.565]         ...future.stdout <- NULL
[01:29:28.565]     }
[01:29:28.565]     ...future.result$conditions <- ...future.conditions
[01:29:28.565]     ...future.result$finished <- base::Sys.time()
[01:29:28.565]     ...future.result
[01:29:28.565] }
[01:29:28.572] assign_globals() ...
[01:29:28.572] List of 1
[01:29:28.572]  $ x: int [1:4] 0 1 2 3
[01:29:28.572]  - attr(*, "where")=List of 1
[01:29:28.572]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.572]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.572]  - attr(*, "resolved")= logi FALSE
[01:29:28.572]  - attr(*, "total_size")= num 64
[01:29:28.572]  - attr(*, "already-done")= logi TRUE
[01:29:28.579] - copied 'x' to environment
[01:29:28.579] assign_globals() ... done
[01:29:28.583] plan(): Setting new future strategy stack:
[01:29:28.583] List of future strategies:
[01:29:28.583] 1. sequential:
[01:29:28.583]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.583]    - tweaked: FALSE
[01:29:28.583]    - call: NULL
[01:29:28.584] plan(): nbrOfWorkers() = 1
[01:29:28.586] plan(): Setting new future strategy stack:
[01:29:28.586] List of future strategies:
[01:29:28.586] 1. sequential:
[01:29:28.586]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.586]    - tweaked: FALSE
[01:29:28.586]    - call: plan(strategy)
[01:29:28.587] plan(): nbrOfWorkers() = 1
[01:29:28.587] SequentialFuture started (and completed)
[01:29:28.587] - Launch lazy future ... done
[01:29:28.588] run() for 'SequentialFuture' ... done
[01:29:28.589] getGlobalsAndPackages() ...
[01:29:28.589] Searching for globals...
[01:29:28.591] - globals found: [3] '{', 'sample', 'x'
[01:29:28.591] Searching for globals ... DONE
[01:29:28.591] Resolving globals: FALSE
[01:29:28.592] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:28.592] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:28.592] - globals: [1] 'x'
[01:29:28.593] 
[01:29:28.593] getGlobalsAndPackages() ... DONE
[01:29:28.593] run() for 'Future' ...
[01:29:28.594] - state: 'created'
[01:29:28.594] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:29:28.594] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:29:28.594] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:29:28.595]   - Field: 'label'
[01:29:28.595]   - Field: 'local'
[01:29:28.595]   - Field: 'owner'
[01:29:28.595]   - Field: 'envir'
[01:29:28.596]   - Field: 'packages'
[01:29:28.596]   - Field: 'gc'
[01:29:28.596]   - Field: 'conditions'
[01:29:28.596]   - Field: 'expr'
[01:29:28.596]   - Field: 'uuid'
[01:29:28.597]   - Field: 'seed'
[01:29:28.597]   - Field: 'version'
[01:29:28.597]   - Field: 'result'
[01:29:28.597]   - Field: 'asynchronous'
[01:29:28.598]   - Field: 'calls'
[01:29:28.598]   - Field: 'globals'
[01:29:28.598]   - Field: 'stdout'
[01:29:28.598]   - Field: 'earlySignal'
[01:29:28.598]   - Field: 'lazy'
[01:29:28.599]   - Field: 'state'
[01:29:28.599] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:29:28.599] - Launch lazy future ...
[01:29:28.599] Packages needed by the future expression (n = 0): <none>
[01:29:28.600] Packages needed by future strategies (n = 0): <none>
[01:29:28.600] {
[01:29:28.600]     {
[01:29:28.600]         {
[01:29:28.600]             ...future.startTime <- base::Sys.time()
[01:29:28.600]             {
[01:29:28.600]                 {
[01:29:28.600]                   {
[01:29:28.600]                     base::local({
[01:29:28.600]                       has_future <- base::requireNamespace("future", 
[01:29:28.600]                         quietly = TRUE)
[01:29:28.600]                       if (has_future) {
[01:29:28.600]                         ns <- base::getNamespace("future")
[01:29:28.600]                         version <- ns[[".package"]][["version"]]
[01:29:28.600]                         if (is.null(version)) 
[01:29:28.600]                           version <- utils::packageVersion("future")
[01:29:28.600]                       }
[01:29:28.600]                       else {
[01:29:28.600]                         version <- NULL
[01:29:28.600]                       }
[01:29:28.600]                       if (!has_future || version < "1.8.0") {
[01:29:28.600]                         info <- base::c(r_version = base::gsub("R version ", 
[01:29:28.600]                           "", base::R.version$version.string), 
[01:29:28.600]                           platform = base::sprintf("%s (%s-bit)", 
[01:29:28.600]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:28.600]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:28.600]                             "release", "version")], collapse = " "), 
[01:29:28.600]                           hostname = base::Sys.info()[["nodename"]])
[01:29:28.600]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:29:28.600]                           info)
[01:29:28.600]                         info <- base::paste(info, collapse = "; ")
[01:29:28.600]                         if (!has_future) {
[01:29:28.600]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:28.600]                             info)
[01:29:28.600]                         }
[01:29:28.600]                         else {
[01:29:28.600]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:28.600]                             info, version)
[01:29:28.600]                         }
[01:29:28.600]                         base::stop(msg)
[01:29:28.600]                       }
[01:29:28.600]                     })
[01:29:28.600]                   }
[01:29:28.600]                   options(future.plan = NULL)
[01:29:28.600]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.600]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:28.600]                 }
[01:29:28.600]                 ...future.workdir <- getwd()
[01:29:28.600]             }
[01:29:28.600]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:28.600]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:28.600]         }
[01:29:28.600]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:28.600]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:28.600]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:28.600]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:28.600]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:28.600]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:28.600]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:28.600]             base::names(...future.oldOptions))
[01:29:28.600]     }
[01:29:28.600]     if (FALSE) {
[01:29:28.600]     }
[01:29:28.600]     else {
[01:29:28.600]         if (TRUE) {
[01:29:28.600]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:28.600]                 open = "w")
[01:29:28.600]         }
[01:29:28.600]         else {
[01:29:28.600]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:28.600]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:28.600]         }
[01:29:28.600]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:28.600]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:28.600]             base::sink(type = "output", split = FALSE)
[01:29:28.600]             base::close(...future.stdout)
[01:29:28.600]         }, add = TRUE)
[01:29:28.600]     }
[01:29:28.600]     ...future.frame <- base::sys.nframe()
[01:29:28.600]     ...future.conditions <- base::list()
[01:29:28.600]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:28.600]     if (FALSE) {
[01:29:28.600]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:28.600]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:28.600]     }
[01:29:28.600]     ...future.result <- base::tryCatch({
[01:29:28.600]         base::withCallingHandlers({
[01:29:28.600]             ...future.value <- base::withVisible(base::local({
[01:29:28.600]                 sample(x, size = 1L)
[01:29:28.600]             }))
[01:29:28.600]             future::FutureResult(value = ...future.value$value, 
[01:29:28.600]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.600]                   ...future.rng), globalenv = if (FALSE) 
[01:29:28.600]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:28.600]                     ...future.globalenv.names))
[01:29:28.600]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:28.600]         }, condition = base::local({
[01:29:28.600]             c <- base::c
[01:29:28.600]             inherits <- base::inherits
[01:29:28.600]             invokeRestart <- base::invokeRestart
[01:29:28.600]             length <- base::length
[01:29:28.600]             list <- base::list
[01:29:28.600]             seq.int <- base::seq.int
[01:29:28.600]             signalCondition <- base::signalCondition
[01:29:28.600]             sys.calls <- base::sys.calls
[01:29:28.600]             `[[` <- base::`[[`
[01:29:28.600]             `+` <- base::`+`
[01:29:28.600]             `<<-` <- base::`<<-`
[01:29:28.600]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:28.600]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:28.600]                   3L)]
[01:29:28.600]             }
[01:29:28.600]             function(cond) {
[01:29:28.600]                 is_error <- inherits(cond, "error")
[01:29:28.600]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:28.600]                   NULL)
[01:29:28.600]                 if (is_error) {
[01:29:28.600]                   sessionInformation <- function() {
[01:29:28.600]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:28.600]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:28.600]                       search = base::search(), system = base::Sys.info())
[01:29:28.600]                   }
[01:29:28.600]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.600]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:28.600]                     cond$call), session = sessionInformation(), 
[01:29:28.600]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:28.600]                   signalCondition(cond)
[01:29:28.600]                 }
[01:29:28.600]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:28.600]                 "immediateCondition"))) {
[01:29:28.600]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:28.600]                   ...future.conditions[[length(...future.conditions) + 
[01:29:28.600]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:28.600]                   if (TRUE && !signal) {
[01:29:28.600]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.600]                     {
[01:29:28.600]                       inherits <- base::inherits
[01:29:28.600]                       invokeRestart <- base::invokeRestart
[01:29:28.600]                       is.null <- base::is.null
[01:29:28.600]                       muffled <- FALSE
[01:29:28.600]                       if (inherits(cond, "message")) {
[01:29:28.600]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.600]                         if (muffled) 
[01:29:28.600]                           invokeRestart("muffleMessage")
[01:29:28.600]                       }
[01:29:28.600]                       else if (inherits(cond, "warning")) {
[01:29:28.600]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.600]                         if (muffled) 
[01:29:28.600]                           invokeRestart("muffleWarning")
[01:29:28.600]                       }
[01:29:28.600]                       else if (inherits(cond, "condition")) {
[01:29:28.600]                         if (!is.null(pattern)) {
[01:29:28.600]                           computeRestarts <- base::computeRestarts
[01:29:28.600]                           grepl <- base::grepl
[01:29:28.600]                           restarts <- computeRestarts(cond)
[01:29:28.600]                           for (restart in restarts) {
[01:29:28.600]                             name <- restart$name
[01:29:28.600]                             if (is.null(name)) 
[01:29:28.600]                               next
[01:29:28.600]                             if (!grepl(pattern, name)) 
[01:29:28.600]                               next
[01:29:28.600]                             invokeRestart(restart)
[01:29:28.600]                             muffled <- TRUE
[01:29:28.600]                             break
[01:29:28.600]                           }
[01:29:28.600]                         }
[01:29:28.600]                       }
[01:29:28.600]                       invisible(muffled)
[01:29:28.600]                     }
[01:29:28.600]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.600]                   }
[01:29:28.600]                 }
[01:29:28.600]                 else {
[01:29:28.600]                   if (TRUE) {
[01:29:28.600]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:28.600]                     {
[01:29:28.600]                       inherits <- base::inherits
[01:29:28.600]                       invokeRestart <- base::invokeRestart
[01:29:28.600]                       is.null <- base::is.null
[01:29:28.600]                       muffled <- FALSE
[01:29:28.600]                       if (inherits(cond, "message")) {
[01:29:28.600]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:28.600]                         if (muffled) 
[01:29:28.600]                           invokeRestart("muffleMessage")
[01:29:28.600]                       }
[01:29:28.600]                       else if (inherits(cond, "warning")) {
[01:29:28.600]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:28.600]                         if (muffled) 
[01:29:28.600]                           invokeRestart("muffleWarning")
[01:29:28.600]                       }
[01:29:28.600]                       else if (inherits(cond, "condition")) {
[01:29:28.600]                         if (!is.null(pattern)) {
[01:29:28.600]                           computeRestarts <- base::computeRestarts
[01:29:28.600]                           grepl <- base::grepl
[01:29:28.600]                           restarts <- computeRestarts(cond)
[01:29:28.600]                           for (restart in restarts) {
[01:29:28.600]                             name <- restart$name
[01:29:28.600]                             if (is.null(name)) 
[01:29:28.600]                               next
[01:29:28.600]                             if (!grepl(pattern, name)) 
[01:29:28.600]                               next
[01:29:28.600]                             invokeRestart(restart)
[01:29:28.600]                             muffled <- TRUE
[01:29:28.600]                             break
[01:29:28.600]                           }
[01:29:28.600]                         }
[01:29:28.600]                       }
[01:29:28.600]                       invisible(muffled)
[01:29:28.600]                     }
[01:29:28.600]                     muffleCondition(cond, pattern = "^muffle")
[01:29:28.600]                   }
[01:29:28.600]                 }
[01:29:28.600]             }
[01:29:28.600]         }))
[01:29:28.600]     }, error = function(ex) {
[01:29:28.600]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:28.600]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:28.600]                 ...future.rng), started = ...future.startTime, 
[01:29:28.600]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:28.600]             version = "1.8"), class = "FutureResult")
[01:29:28.600]     }, finally = {
[01:29:28.600]         if (!identical(...future.workdir, getwd())) 
[01:29:28.600]             setwd(...future.workdir)
[01:29:28.600]         {
[01:29:28.600]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:28.600]                 ...future.oldOptions$nwarnings <- NULL
[01:29:28.600]             }
[01:29:28.600]             base::options(...future.oldOptions)
[01:29:28.600]             if (.Platform$OS.type == "windows") {
[01:29:28.600]                 old_names <- names(...future.oldEnvVars)
[01:29:28.600]                 envs <- base::Sys.getenv()
[01:29:28.600]                 names <- names(envs)
[01:29:28.600]                 common <- intersect(names, old_names)
[01:29:28.600]                 added <- setdiff(names, old_names)
[01:29:28.600]                 removed <- setdiff(old_names, names)
[01:29:28.600]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:28.600]                   envs[common]]
[01:29:28.600]                 NAMES <- toupper(changed)
[01:29:28.600]                 args <- list()
[01:29:28.600]                 for (kk in seq_along(NAMES)) {
[01:29:28.600]                   name <- changed[[kk]]
[01:29:28.600]                   NAME <- NAMES[[kk]]
[01:29:28.600]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.600]                     next
[01:29:28.600]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.600]                 }
[01:29:28.600]                 NAMES <- toupper(added)
[01:29:28.600]                 for (kk in seq_along(NAMES)) {
[01:29:28.600]                   name <- added[[kk]]
[01:29:28.600]                   NAME <- NAMES[[kk]]
[01:29:28.600]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.600]                     next
[01:29:28.600]                   args[[name]] <- ""
[01:29:28.600]                 }
[01:29:28.600]                 NAMES <- toupper(removed)
[01:29:28.600]                 for (kk in seq_along(NAMES)) {
[01:29:28.600]                   name <- removed[[kk]]
[01:29:28.600]                   NAME <- NAMES[[kk]]
[01:29:28.600]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:28.600]                     next
[01:29:28.600]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:28.600]                 }
[01:29:28.600]                 if (length(args) > 0) 
[01:29:28.600]                   base::do.call(base::Sys.setenv, args = args)
[01:29:28.600]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:28.600]             }
[01:29:28.600]             else {
[01:29:28.600]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:28.600]             }
[01:29:28.600]             {
[01:29:28.600]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:28.600]                   0L) {
[01:29:28.600]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:28.600]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:28.600]                   base::options(opts)
[01:29:28.600]                 }
[01:29:28.600]                 {
[01:29:28.600]                   {
[01:29:28.600]                     base::assign(".Random.seed", c(10407L, -1269930425L, 
[01:29:28.600]                     -192946844L, 1503370635L, -1338438503L, 1874105503L, 
[01:29:28.600]                     60389135L), envir = base::globalenv(), inherits = FALSE)
[01:29:28.600]                     NULL
[01:29:28.600]                   }
[01:29:28.600]                   options(future.plan = NULL)
[01:29:28.600]                   if (is.na(NA_character_)) 
[01:29:28.600]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:28.600]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:28.600]                   future::plan(list(function (..., envir = parent.frame()) 
[01:29:28.600]                   {
[01:29:28.600]                     future <- SequentialFuture(..., envir = envir)
[01:29:28.600]                     if (!future$lazy) 
[01:29:28.600]                       future <- run(future)
[01:29:28.600]                     invisible(future)
[01:29:28.600]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:28.600]                 }
[01:29:28.600]             }
[01:29:28.600]         }
[01:29:28.600]     })
[01:29:28.600]     if (TRUE) {
[01:29:28.600]         base::sink(type = "output", split = FALSE)
[01:29:28.600]         if (TRUE) {
[01:29:28.600]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:28.600]         }
[01:29:28.600]         else {
[01:29:28.600]             ...future.result["stdout"] <- base::list(NULL)
[01:29:28.600]         }
[01:29:28.600]         base::close(...future.stdout)
[01:29:28.600]         ...future.stdout <- NULL
[01:29:28.600]     }
[01:29:28.600]     ...future.result$conditions <- ...future.conditions
[01:29:28.600]     ...future.result$finished <- base::Sys.time()
[01:29:28.600]     ...future.result
[01:29:28.600] }
[01:29:28.604] assign_globals() ...
[01:29:28.604] List of 1
[01:29:28.604]  $ x: int [1:4] 0 1 2 3
[01:29:28.604]  - attr(*, "where")=List of 1
[01:29:28.604]   ..$ x:<environment: R_EmptyEnv> 
[01:29:28.604]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:29:28.604]  - attr(*, "resolved")= logi FALSE
[01:29:28.604]  - attr(*, "total_size")= num 64
[01:29:28.604]  - attr(*, "already-done")= logi TRUE
[01:29:28.608] - copied 'x' to environment
[01:29:28.608] assign_globals() ... done
[01:29:28.609] plan(): Setting new future strategy stack:
[01:29:28.609] List of future strategies:
[01:29:28.609] 1. sequential:
[01:29:28.609]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.609]    - tweaked: FALSE
[01:29:28.609]    - call: NULL
[01:29:28.610] plan(): nbrOfWorkers() = 1
[01:29:28.611] plan(): Setting new future strategy stack:
[01:29:28.611] List of future strategies:
[01:29:28.611] 1. sequential:
[01:29:28.611]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:29:28.611]    - tweaked: FALSE
[01:29:28.611]    - call: plan(strategy)
[01:29:28.612] plan(): nbrOfWorkers() = 1
[01:29:28.612] SequentialFuture started (and completed)
[01:29:28.612] - Launch lazy future ... done
[01:29:28.613] run() for 'SequentialFuture' ... done
[[1]]
[1] 0

[[2]]
[1] 0

[[3]]
[1] 3

[[4]]
[1] 3

sequential ... done
Testing with 1 cores ... DONE
Testing with 2 cores ...
multisession ...
[01:29:28.623] plan(): Setting new future strategy stack:
[01:29:28.623] List of future strategies:
[01:29:28.623] 1. multisession:
[01:29:28.623]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:29:28.623]    - tweaked: FALSE
[01:29:28.623]    - call: plan(strategy)
[01:29:28.624] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[01:29:28.624] multisession:
[01:29:28.624] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:29:28.624] - tweaked: FALSE
[01:29:28.624] - call: plan(strategy)
[01:29:28.629] getGlobalsAndPackages() ...
[01:29:28.629] Not searching for globals
[01:29:28.630] - globals: [0] <none>
[01:29:28.630] getGlobalsAndPackages() ... DONE
[01:29:28.630] [local output] makeClusterPSOCK() ...
[01:29:28.701] [local output] Workers: [n = 2] 'localhost', 'localhost'
[01:29:28.708] [local output] Base port: 27617
[01:29:28.708] [local output] Getting setup options for 2 cluster nodes ...
[01:29:28.709] [local output]  - Node 1 of 2 ...
[01:29:28.709] [local output] localMachine=TRUE => revtunnel=FALSE

[01:29:28.711] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpC6y6SF/worker.rank=1.parallelly.parent=10200.27d87b514853.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpC6y6SF/worker.rank=1.parallelly.parent=10200.27d87b514853.pid\")"'
[01:29:29.159] - Possible to infer worker's PID: TRUE
[01:29:29.160] [local output] Rscript port: 27617

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

[01:29:29.162] [local output] Rscript port: 27617

[01:29:29.163] [local output] Getting setup options for 2 cluster nodes ... done
[01:29:29.163] [local output]  - Parallel setup requested for some PSOCK nodes
[01:29:29.164] [local output] Setting up PSOCK nodes in parallel
[01:29:29.164] List of 36
[01:29:29.164]  $ worker          : chr "localhost"
[01:29:29.164]   ..- attr(*, "localhost")= logi TRUE
[01:29:29.164]  $ master          : chr "localhost"
[01:29:29.164]  $ port            : int 27617
[01:29:29.164]  $ connectTimeout  : num 120
[01:29:29.164]  $ timeout         : num 120
[01:29:29.164]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[01:29:29.164]  $ homogeneous     : logi TRUE
[01:29:29.164]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=rng.R:10200:CRANWIN3:CRAN\" -e \"| __truncated__
[01:29:29.164]  $ rscript_envs    : NULL
[01:29:29.164]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:29:29.164]  $ rscript_startup : NULL
[01:29:29.164]  $ rscript_sh      : chr "cmd"
[01:29:29.164]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:29:29.164]  $ methods         : logi TRUE
[01:29:29.164]  $ socketOptions   : chr "no-delay"
[01:29:29.164]  $ useXDR          : logi FALSE
[01:29:29.164]  $ outfile         : chr "/dev/null"
[01:29:29.164]  $ renice          : int NA
[01:29:29.164]  $ rshcmd          : NULL
[01:29:29.164]  $ user            : chr(0) 
[01:29:29.164]  $ revtunnel       : logi FALSE
[01:29:29.164]  $ rshlogfile      : NULL
[01:29:29.164]  $ rshopts         : chr(0) 
[01:29:29.164]  $ rank            : int 1
[01:29:29.164]  $ manual          : logi FALSE
[01:29:29.164]  $ dryrun          : logi FALSE
[01:29:29.164]  $ quiet           : logi FALSE
[01:29:29.164]  $ setup_strategy  : chr "parallel"
[01:29:29.164]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:29:29.164]  $ pidfile         : chr "D:/temp/RtmpC6y6SF/worker.rank=1.parallelly.parent=10200.27d87b514853.pid"
[01:29:29.164]  $ rshcmd_label    : NULL
[01:29:29.164]  $ rsh_call        : NULL
[01:29:29.164]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:29:29.164]  $ localMachine    : logi TRUE
[01:29:29.164]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[01:29:29.164]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[01:29:29.164]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[01:29:29.164]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[01:29:29.164]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[01:29:29.164]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[01:29:29.164]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[01:29:29.164]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[01:29:29.164]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[01:29:29.164]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[01:29:29.164]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[01:29:29.164]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[01:29:29.164]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[01:29:29.164]  $ arguments       :List of 28
[01:29:29.164]   ..$ worker          : chr "localhost"
[01:29:29.164]   ..$ master          : NULL
[01:29:29.164]   ..$ port            : int 27617
[01:29:29.164]   ..$ connectTimeout  : num 120
[01:29:29.164]   ..$ timeout         : num 120
[01:29:29.164]   ..$ rscript         : NULL
[01:29:29.164]   ..$ homogeneous     : NULL
[01:29:29.164]   ..$ rscript_args    : NULL
[01:29:29.164]   ..$ rscript_envs    : NULL
[01:29:29.164]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:29:29.164]   ..$ rscript_startup : NULL
[01:29:29.164]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[01:29:29.164]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:29:29.164]   ..$ methods         : logi TRUE
[01:29:29.164]   ..$ socketOptions   : chr "no-delay"
[01:29:29.164]   ..$ useXDR          : logi FALSE
[01:29:29.164]   ..$ outfile         : chr "/dev/null"
[01:29:29.164]   ..$ renice          : int NA
[01:29:29.164]   ..$ rshcmd          : NULL
[01:29:29.164]   ..$ user            : NULL
[01:29:29.164]   ..$ revtunnel       : logi NA
[01:29:29.164]   ..$ rshlogfile      : NULL
[01:29:29.164]   ..$ rshopts         : NULL
[01:29:29.164]   ..$ rank            : int 1
[01:29:29.164]   ..$ manual          : logi FALSE
[01:29:29.164]   ..$ dryrun          : logi FALSE
[01:29:29.164]   ..$ quiet           : logi FALSE
[01:29:29.164]   ..$ setup_strategy  : chr "parallel"
[01:29:29.164]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[01:29:29.186] [local output] System call to launch all workers:
[01:29:29.186] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=rng.R:10200:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpC6y6SF/worker.rank=1.parallelly.parent=10200.27d87b514853.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=27617 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[01:29:29.186] [local output] Starting PSOCK main server
[01:29:29.192] [local output] Workers launched
[01:29:29.193] [local output] Waiting for workers to connect back
[01:29:29.193]  - [local output] 0 workers out of 2 ready
[01:29:29.363]  - [local output] 0 workers out of 2 ready
[01:29:29.364]  - [local output] 1 workers out of 2 ready
[01:29:29.377]  - [local output] 1 workers out of 2 ready
[01:29:29.377]  - [local output] 2 workers out of 2 ready
[01:29:29.378] [local output] Launching of workers completed
[01:29:29.378] [local output] Collecting session information from workers
[01:29:29.379] [local output]  - Worker #1 of 2
[01:29:29.380] [local output]  - Worker #2 of 2
[01:29:29.380] [local output] makeClusterPSOCK() ... done
[01:29:29.394] Packages needed by the future expression (n = 0): <none>
[01:29:29.395] Packages needed by future strategies (n = 0): <none>
[01:29:29.396] {
[01:29:29.396]     {
[01:29:29.396]         {
[01:29:29.396]             ...future.startTime <- base::Sys.time()
[01:29:29.396]             {
[01:29:29.396]                 {
[01:29:29.396]                   {
[01:29:29.396]                     {
[01:29:29.396]                       base::local({
[01:29:29.396]                         has_future <- base::requireNamespace("future", 
[01:29:29.396]                           quietly = TRUE)
[01:29:29.396]                         if (has_future) {
[01:29:29.396]                           ns <- base::getNamespace("future")
[01:29:29.396]                           version <- ns[[".package"]][["version"]]
[01:29:29.396]                           if (is.null(version)) 
[01:29:29.396]                             version <- utils::packageVersion("future")
[01:29:29.396]                         }
[01:29:29.396]                         else {
[01:29:29.396]                           version <- NULL
[01:29:29.396]                         }
[01:29:29.396]                         if (!has_future || version < "1.8.0") {
[01:29:29.396]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:29.396]                             "", base::R.version$version.string), 
[01:29:29.396]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:29.396]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:29.396]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:29.396]                               "release", "version")], collapse = " "), 
[01:29:29.396]                             hostname = base::Sys.info()[["nodename"]])
[01:29:29.396]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:29.396]                             info)
[01:29:29.396]                           info <- base::paste(info, collapse = "; ")
[01:29:29.396]                           if (!has_future) {
[01:29:29.396]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:29.396]                               info)
[01:29:29.396]                           }
[01:29:29.396]                           else {
[01:29:29.396]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:29.396]                               info, version)
[01:29:29.396]                           }
[01:29:29.396]                           base::stop(msg)
[01:29:29.396]                         }
[01:29:29.396]                       })
[01:29:29.396]                     }
[01:29:29.396]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:29.396]                     base::options(mc.cores = 1L)
[01:29:29.396]                   }
[01:29:29.396]                   options(future.plan = NULL)
[01:29:29.396]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:29.396]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:29.396]                 }
[01:29:29.396]                 ...future.workdir <- getwd()
[01:29:29.396]             }
[01:29:29.396]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:29.396]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:29.396]         }
[01:29:29.396]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:29.396]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:29.396]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:29.396]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:29.396]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:29.396]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:29.396]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:29.396]             base::names(...future.oldOptions))
[01:29:29.396]     }
[01:29:29.396]     if (FALSE) {
[01:29:29.396]     }
[01:29:29.396]     else {
[01:29:29.396]         if (TRUE) {
[01:29:29.396]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:29.396]                 open = "w")
[01:29:29.396]         }
[01:29:29.396]         else {
[01:29:29.396]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:29.396]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:29.396]         }
[01:29:29.396]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:29.396]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:29.396]             base::sink(type = "output", split = FALSE)
[01:29:29.396]             base::close(...future.stdout)
[01:29:29.396]         }, add = TRUE)
[01:29:29.396]     }
[01:29:29.396]     ...future.frame <- base::sys.nframe()
[01:29:29.396]     ...future.conditions <- base::list()
[01:29:29.396]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:29.396]     if (FALSE) {
[01:29:29.396]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:29.396]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:29.396]     }
[01:29:29.396]     ...future.result <- base::tryCatch({
[01:29:29.396]         base::withCallingHandlers({
[01:29:29.396]             ...future.value <- base::withVisible(base::local({
[01:29:29.396]                 ...future.makeSendCondition <- base::local({
[01:29:29.396]                   sendCondition <- NULL
[01:29:29.396]                   function(frame = 1L) {
[01:29:29.396]                     if (is.function(sendCondition)) 
[01:29:29.396]                       return(sendCondition)
[01:29:29.396]                     ns <- getNamespace("parallel")
[01:29:29.396]                     if (exists("sendData", mode = "function", 
[01:29:29.396]                       envir = ns)) {
[01:29:29.396]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:29.396]                         envir = ns)
[01:29:29.396]                       envir <- sys.frame(frame)
[01:29:29.396]                       master <- NULL
[01:29:29.396]                       while (!identical(envir, .GlobalEnv) && 
[01:29:29.396]                         !identical(envir, emptyenv())) {
[01:29:29.396]                         if (exists("master", mode = "list", envir = envir, 
[01:29:29.396]                           inherits = FALSE)) {
[01:29:29.396]                           master <- get("master", mode = "list", 
[01:29:29.396]                             envir = envir, inherits = FALSE)
[01:29:29.396]                           if (inherits(master, c("SOCKnode", 
[01:29:29.396]                             "SOCK0node"))) {
[01:29:29.396]                             sendCondition <<- function(cond) {
[01:29:29.396]                               data <- list(type = "VALUE", value = cond, 
[01:29:29.396]                                 success = TRUE)
[01:29:29.396]                               parallel_sendData(master, data)
[01:29:29.396]                             }
[01:29:29.396]                             return(sendCondition)
[01:29:29.396]                           }
[01:29:29.396]                         }
[01:29:29.396]                         frame <- frame + 1L
[01:29:29.396]                         envir <- sys.frame(frame)
[01:29:29.396]                       }
[01:29:29.396]                     }
[01:29:29.396]                     sendCondition <<- function(cond) NULL
[01:29:29.396]                   }
[01:29:29.396]                 })
[01:29:29.396]                 withCallingHandlers({
[01:29:29.396]                   NA
[01:29:29.396]                 }, immediateCondition = function(cond) {
[01:29:29.396]                   sendCondition <- ...future.makeSendCondition()
[01:29:29.396]                   sendCondition(cond)
[01:29:29.396]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.396]                   {
[01:29:29.396]                     inherits <- base::inherits
[01:29:29.396]                     invokeRestart <- base::invokeRestart
[01:29:29.396]                     is.null <- base::is.null
[01:29:29.396]                     muffled <- FALSE
[01:29:29.396]                     if (inherits(cond, "message")) {
[01:29:29.396]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:29.396]                       if (muffled) 
[01:29:29.396]                         invokeRestart("muffleMessage")
[01:29:29.396]                     }
[01:29:29.396]                     else if (inherits(cond, "warning")) {
[01:29:29.396]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:29.396]                       if (muffled) 
[01:29:29.396]                         invokeRestart("muffleWarning")
[01:29:29.396]                     }
[01:29:29.396]                     else if (inherits(cond, "condition")) {
[01:29:29.396]                       if (!is.null(pattern)) {
[01:29:29.396]                         computeRestarts <- base::computeRestarts
[01:29:29.396]                         grepl <- base::grepl
[01:29:29.396]                         restarts <- computeRestarts(cond)
[01:29:29.396]                         for (restart in restarts) {
[01:29:29.396]                           name <- restart$name
[01:29:29.396]                           if (is.null(name)) 
[01:29:29.396]                             next
[01:29:29.396]                           if (!grepl(pattern, name)) 
[01:29:29.396]                             next
[01:29:29.396]                           invokeRestart(restart)
[01:29:29.396]                           muffled <- TRUE
[01:29:29.396]                           break
[01:29:29.396]                         }
[01:29:29.396]                       }
[01:29:29.396]                     }
[01:29:29.396]                     invisible(muffled)
[01:29:29.396]                   }
[01:29:29.396]                   muffleCondition(cond)
[01:29:29.396]                 })
[01:29:29.396]             }))
[01:29:29.396]             future::FutureResult(value = ...future.value$value, 
[01:29:29.396]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:29.396]                   ...future.rng), globalenv = if (FALSE) 
[01:29:29.396]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:29.396]                     ...future.globalenv.names))
[01:29:29.396]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:29.396]         }, condition = base::local({
[01:29:29.396]             c <- base::c
[01:29:29.396]             inherits <- base::inherits
[01:29:29.396]             invokeRestart <- base::invokeRestart
[01:29:29.396]             length <- base::length
[01:29:29.396]             list <- base::list
[01:29:29.396]             seq.int <- base::seq.int
[01:29:29.396]             signalCondition <- base::signalCondition
[01:29:29.396]             sys.calls <- base::sys.calls
[01:29:29.396]             `[[` <- base::`[[`
[01:29:29.396]             `+` <- base::`+`
[01:29:29.396]             `<<-` <- base::`<<-`
[01:29:29.396]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:29.396]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:29.396]                   3L)]
[01:29:29.396]             }
[01:29:29.396]             function(cond) {
[01:29:29.396]                 is_error <- inherits(cond, "error")
[01:29:29.396]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:29.396]                   NULL)
[01:29:29.396]                 if (is_error) {
[01:29:29.396]                   sessionInformation <- function() {
[01:29:29.396]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:29.396]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:29.396]                       search = base::search(), system = base::Sys.info())
[01:29:29.396]                   }
[01:29:29.396]                   ...future.conditions[[length(...future.conditions) + 
[01:29:29.396]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:29.396]                     cond$call), session = sessionInformation(), 
[01:29:29.396]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:29.396]                   signalCondition(cond)
[01:29:29.396]                 }
[01:29:29.396]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:29.396]                 "immediateCondition"))) {
[01:29:29.396]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:29.396]                   ...future.conditions[[length(...future.conditions) + 
[01:29:29.396]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:29.396]                   if (TRUE && !signal) {
[01:29:29.396]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.396]                     {
[01:29:29.396]                       inherits <- base::inherits
[01:29:29.396]                       invokeRestart <- base::invokeRestart
[01:29:29.396]                       is.null <- base::is.null
[01:29:29.396]                       muffled <- FALSE
[01:29:29.396]                       if (inherits(cond, "message")) {
[01:29:29.396]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:29.396]                         if (muffled) 
[01:29:29.396]                           invokeRestart("muffleMessage")
[01:29:29.396]                       }
[01:29:29.396]                       else if (inherits(cond, "warning")) {
[01:29:29.396]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:29.396]                         if (muffled) 
[01:29:29.396]                           invokeRestart("muffleWarning")
[01:29:29.396]                       }
[01:29:29.396]                       else if (inherits(cond, "condition")) {
[01:29:29.396]                         if (!is.null(pattern)) {
[01:29:29.396]                           computeRestarts <- base::computeRestarts
[01:29:29.396]                           grepl <- base::grepl
[01:29:29.396]                           restarts <- computeRestarts(cond)
[01:29:29.396]                           for (restart in restarts) {
[01:29:29.396]                             name <- restart$name
[01:29:29.396]                             if (is.null(name)) 
[01:29:29.396]                               next
[01:29:29.396]                             if (!grepl(pattern, name)) 
[01:29:29.396]                               next
[01:29:29.396]                             invokeRestart(restart)
[01:29:29.396]                             muffled <- TRUE
[01:29:29.396]                             break
[01:29:29.396]                           }
[01:29:29.396]                         }
[01:29:29.396]                       }
[01:29:29.396]                       invisible(muffled)
[01:29:29.396]                     }
[01:29:29.396]                     muffleCondition(cond, pattern = "^muffle")
[01:29:29.396]                   }
[01:29:29.396]                 }
[01:29:29.396]                 else {
[01:29:29.396]                   if (TRUE) {
[01:29:29.396]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.396]                     {
[01:29:29.396]                       inherits <- base::inherits
[01:29:29.396]                       invokeRestart <- base::invokeRestart
[01:29:29.396]                       is.null <- base::is.null
[01:29:29.396]                       muffled <- FALSE
[01:29:29.396]                       if (inherits(cond, "message")) {
[01:29:29.396]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:29.396]                         if (muffled) 
[01:29:29.396]                           invokeRestart("muffleMessage")
[01:29:29.396]                       }
[01:29:29.396]                       else if (inherits(cond, "warning")) {
[01:29:29.396]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:29.396]                         if (muffled) 
[01:29:29.396]                           invokeRestart("muffleWarning")
[01:29:29.396]                       }
[01:29:29.396]                       else if (inherits(cond, "condition")) {
[01:29:29.396]                         if (!is.null(pattern)) {
[01:29:29.396]                           computeRestarts <- base::computeRestarts
[01:29:29.396]                           grepl <- base::grepl
[01:29:29.396]                           restarts <- computeRestarts(cond)
[01:29:29.396]                           for (restart in restarts) {
[01:29:29.396]                             name <- restart$name
[01:29:29.396]                             if (is.null(name)) 
[01:29:29.396]                               next
[01:29:29.396]                             if (!grepl(pattern, name)) 
[01:29:29.396]                               next
[01:29:29.396]                             invokeRestart(restart)
[01:29:29.396]                             muffled <- TRUE
[01:29:29.396]                             break
[01:29:29.396]                           }
[01:29:29.396]                         }
[01:29:29.396]                       }
[01:29:29.396]                       invisible(muffled)
[01:29:29.396]                     }
[01:29:29.396]                     muffleCondition(cond, pattern = "^muffle")
[01:29:29.396]                   }
[01:29:29.396]                 }
[01:29:29.396]             }
[01:29:29.396]         }))
[01:29:29.396]     }, error = function(ex) {
[01:29:29.396]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:29.396]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:29.396]                 ...future.rng), started = ...future.startTime, 
[01:29:29.396]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:29.396]             version = "1.8"), class = "FutureResult")
[01:29:29.396]     }, finally = {
[01:29:29.396]         if (!identical(...future.workdir, getwd())) 
[01:29:29.396]             setwd(...future.workdir)
[01:29:29.396]         {
[01:29:29.396]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:29.396]                 ...future.oldOptions$nwarnings <- NULL
[01:29:29.396]             }
[01:29:29.396]             base::options(...future.oldOptions)
[01:29:29.396]             if (.Platform$OS.type == "windows") {
[01:29:29.396]                 old_names <- names(...future.oldEnvVars)
[01:29:29.396]                 envs <- base::Sys.getenv()
[01:29:29.396]                 names <- names(envs)
[01:29:29.396]                 common <- intersect(names, old_names)
[01:29:29.396]                 added <- setdiff(names, old_names)
[01:29:29.396]                 removed <- setdiff(old_names, names)
[01:29:29.396]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:29.396]                   envs[common]]
[01:29:29.396]                 NAMES <- toupper(changed)
[01:29:29.396]                 args <- list()
[01:29:29.396]                 for (kk in seq_along(NAMES)) {
[01:29:29.396]                   name <- changed[[kk]]
[01:29:29.396]                   NAME <- NAMES[[kk]]
[01:29:29.396]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.396]                     next
[01:29:29.396]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:29.396]                 }
[01:29:29.396]                 NAMES <- toupper(added)
[01:29:29.396]                 for (kk in seq_along(NAMES)) {
[01:29:29.396]                   name <- added[[kk]]
[01:29:29.396]                   NAME <- NAMES[[kk]]
[01:29:29.396]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.396]                     next
[01:29:29.396]                   args[[name]] <- ""
[01:29:29.396]                 }
[01:29:29.396]                 NAMES <- toupper(removed)
[01:29:29.396]                 for (kk in seq_along(NAMES)) {
[01:29:29.396]                   name <- removed[[kk]]
[01:29:29.396]                   NAME <- NAMES[[kk]]
[01:29:29.396]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.396]                     next
[01:29:29.396]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:29.396]                 }
[01:29:29.396]                 if (length(args) > 0) 
[01:29:29.396]                   base::do.call(base::Sys.setenv, args = args)
[01:29:29.396]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:29.396]             }
[01:29:29.396]             else {
[01:29:29.396]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:29.396]             }
[01:29:29.396]             {
[01:29:29.396]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:29.396]                   0L) {
[01:29:29.396]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:29.396]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:29.396]                   base::options(opts)
[01:29:29.396]                 }
[01:29:29.396]                 {
[01:29:29.396]                   {
[01:29:29.396]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:29.396]                     NULL
[01:29:29.396]                   }
[01:29:29.396]                   options(future.plan = NULL)
[01:29:29.396]                   if (is.na(NA_character_)) 
[01:29:29.396]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:29.396]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:29.396]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:29.396]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:29.396]                     envir = parent.frame()) 
[01:29:29.396]                   {
[01:29:29.396]                     if (is.function(workers)) 
[01:29:29.396]                       workers <- workers()
[01:29:29.396]                     workers <- structure(as.integer(workers), 
[01:29:29.396]                       class = class(workers))
[01:29:29.396]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:29.396]                       workers >= 1)
[01:29:29.396]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:29.396]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:29.396]                     }
[01:29:29.396]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:29.396]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:29.396]                       envir = envir)
[01:29:29.396]                     if (!future$lazy) 
[01:29:29.396]                       future <- run(future)
[01:29:29.396]                     invisible(future)
[01:29:29.396]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:29.396]                 }
[01:29:29.396]             }
[01:29:29.396]         }
[01:29:29.396]     })
[01:29:29.396]     if (TRUE) {
[01:29:29.396]         base::sink(type = "output", split = FALSE)
[01:29:29.396]         if (TRUE) {
[01:29:29.396]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:29.396]         }
[01:29:29.396]         else {
[01:29:29.396]             ...future.result["stdout"] <- base::list(NULL)
[01:29:29.396]         }
[01:29:29.396]         base::close(...future.stdout)
[01:29:29.396]         ...future.stdout <- NULL
[01:29:29.396]     }
[01:29:29.396]     ...future.result$conditions <- ...future.conditions
[01:29:29.396]     ...future.result$finished <- base::Sys.time()
[01:29:29.396]     ...future.result
[01:29:29.396] }
[01:29:29.484] MultisessionFuture started
[01:29:29.484] result() for ClusterFuture ...
[01:29:29.485] receiveMessageFromWorker() for ClusterFuture ...
[01:29:29.485] - Validating connection of MultisessionFuture
[01:29:29.552] - received message: FutureResult
[01:29:29.553] - Received FutureResult
[01:29:29.556] - Erased future from FutureRegistry
[01:29:29.556] result() for ClusterFuture ...
[01:29:29.557] - result already collected: FutureResult
[01:29:29.557] result() for ClusterFuture ... done
[01:29:29.557] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:29.557] result() for ClusterFuture ... done
[01:29:29.557] result() for ClusterFuture ...
[01:29:29.557] - result already collected: FutureResult
[01:29:29.558] result() for ClusterFuture ... done
[01:29:29.558] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[01:29:29.561] plan(): nbrOfWorkers() = 2
[01:29:29.561] getGlobalsAndPackages() ...
[01:29:29.561] Searching for globals...
[01:29:29.565] - globals found: [3] '{', 'sample', 'x'
[01:29:29.566] Searching for globals ... DONE
[01:29:29.566] Resolving globals: FALSE
[01:29:29.567] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:29.567] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:29.567] - globals: [1] 'x'
[01:29:29.568] 
[01:29:29.568] getGlobalsAndPackages() ... DONE
[01:29:29.568] run() for 'Future' ...
[01:29:29.568] - state: 'created'
[01:29:29.569] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:29.583] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:29.584] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:29.584]   - Field: 'node'
[01:29:29.584]   - Field: 'label'
[01:29:29.584]   - Field: 'local'
[01:29:29.584]   - Field: 'owner'
[01:29:29.585]   - Field: 'envir'
[01:29:29.585]   - Field: 'workers'
[01:29:29.585]   - Field: 'packages'
[01:29:29.585]   - Field: 'gc'
[01:29:29.585]   - Field: 'conditions'
[01:29:29.586]   - Field: 'persistent'
[01:29:29.586]   - Field: 'expr'
[01:29:29.586]   - Field: 'uuid'
[01:29:29.586]   - Field: 'seed'
[01:29:29.586]   - Field: 'version'
[01:29:29.587]   - Field: 'result'
[01:29:29.587]   - Field: 'asynchronous'
[01:29:29.587]   - Field: 'calls'
[01:29:29.587]   - Field: 'globals'
[01:29:29.587]   - Field: 'stdout'
[01:29:29.588]   - Field: 'earlySignal'
[01:29:29.588]   - Field: 'lazy'
[01:29:29.588]   - Field: 'state'
[01:29:29.588] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:29.588] - Launch lazy future ...
[01:29:29.589] Packages needed by the future expression (n = 0): <none>
[01:29:29.589] Packages needed by future strategies (n = 0): <none>
[01:29:29.590] {
[01:29:29.590]     {
[01:29:29.590]         {
[01:29:29.590]             ...future.startTime <- base::Sys.time()
[01:29:29.590]             {
[01:29:29.590]                 {
[01:29:29.590]                   {
[01:29:29.590]                     {
[01:29:29.590]                       {
[01:29:29.590]                         base::local({
[01:29:29.590]                           has_future <- base::requireNamespace("future", 
[01:29:29.590]                             quietly = TRUE)
[01:29:29.590]                           if (has_future) {
[01:29:29.590]                             ns <- base::getNamespace("future")
[01:29:29.590]                             version <- ns[[".package"]][["version"]]
[01:29:29.590]                             if (is.null(version)) 
[01:29:29.590]                               version <- utils::packageVersion("future")
[01:29:29.590]                           }
[01:29:29.590]                           else {
[01:29:29.590]                             version <- NULL
[01:29:29.590]                           }
[01:29:29.590]                           if (!has_future || version < "1.8.0") {
[01:29:29.590]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:29.590]                               "", base::R.version$version.string), 
[01:29:29.590]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:29.590]                                 base::R.version$platform, 8 * 
[01:29:29.590]                                   base::.Machine$sizeof.pointer), 
[01:29:29.590]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:29.590]                                 "release", "version")], collapse = " "), 
[01:29:29.590]                               hostname = base::Sys.info()[["nodename"]])
[01:29:29.590]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:29.590]                               info)
[01:29:29.590]                             info <- base::paste(info, collapse = "; ")
[01:29:29.590]                             if (!has_future) {
[01:29:29.590]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:29.590]                                 info)
[01:29:29.590]                             }
[01:29:29.590]                             else {
[01:29:29.590]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:29.590]                                 info, version)
[01:29:29.590]                             }
[01:29:29.590]                             base::stop(msg)
[01:29:29.590]                           }
[01:29:29.590]                         })
[01:29:29.590]                       }
[01:29:29.590]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:29.590]                       base::options(mc.cores = 1L)
[01:29:29.590]                     }
[01:29:29.590]                     options(future.plan = NULL)
[01:29:29.590]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:29.590]                     future::plan("default", .cleanup = FALSE, 
[01:29:29.590]                       .init = FALSE)
[01:29:29.590]                   }
[01:29:29.590]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[01:29:29.590]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[01:29:29.590]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[01:29:29.590]                 }
[01:29:29.590]                 ...future.workdir <- getwd()
[01:29:29.590]             }
[01:29:29.590]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:29.590]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:29.590]         }
[01:29:29.590]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:29.590]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:29.590]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:29.590]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:29.590]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:29.590]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:29.590]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:29.590]             base::names(...future.oldOptions))
[01:29:29.590]     }
[01:29:29.590]     if (FALSE) {
[01:29:29.590]     }
[01:29:29.590]     else {
[01:29:29.590]         if (TRUE) {
[01:29:29.590]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:29.590]                 open = "w")
[01:29:29.590]         }
[01:29:29.590]         else {
[01:29:29.590]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:29.590]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:29.590]         }
[01:29:29.590]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:29.590]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:29.590]             base::sink(type = "output", split = FALSE)
[01:29:29.590]             base::close(...future.stdout)
[01:29:29.590]         }, add = TRUE)
[01:29:29.590]     }
[01:29:29.590]     ...future.frame <- base::sys.nframe()
[01:29:29.590]     ...future.conditions <- base::list()
[01:29:29.590]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:29.590]     if (FALSE) {
[01:29:29.590]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:29.590]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:29.590]     }
[01:29:29.590]     ...future.result <- base::tryCatch({
[01:29:29.590]         base::withCallingHandlers({
[01:29:29.590]             ...future.value <- base::withVisible(base::local({
[01:29:29.590]                 ...future.makeSendCondition <- base::local({
[01:29:29.590]                   sendCondition <- NULL
[01:29:29.590]                   function(frame = 1L) {
[01:29:29.590]                     if (is.function(sendCondition)) 
[01:29:29.590]                       return(sendCondition)
[01:29:29.590]                     ns <- getNamespace("parallel")
[01:29:29.590]                     if (exists("sendData", mode = "function", 
[01:29:29.590]                       envir = ns)) {
[01:29:29.590]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:29.590]                         envir = ns)
[01:29:29.590]                       envir <- sys.frame(frame)
[01:29:29.590]                       master <- NULL
[01:29:29.590]                       while (!identical(envir, .GlobalEnv) && 
[01:29:29.590]                         !identical(envir, emptyenv())) {
[01:29:29.590]                         if (exists("master", mode = "list", envir = envir, 
[01:29:29.590]                           inherits = FALSE)) {
[01:29:29.590]                           master <- get("master", mode = "list", 
[01:29:29.590]                             envir = envir, inherits = FALSE)
[01:29:29.590]                           if (inherits(master, c("SOCKnode", 
[01:29:29.590]                             "SOCK0node"))) {
[01:29:29.590]                             sendCondition <<- function(cond) {
[01:29:29.590]                               data <- list(type = "VALUE", value = cond, 
[01:29:29.590]                                 success = TRUE)
[01:29:29.590]                               parallel_sendData(master, data)
[01:29:29.590]                             }
[01:29:29.590]                             return(sendCondition)
[01:29:29.590]                           }
[01:29:29.590]                         }
[01:29:29.590]                         frame <- frame + 1L
[01:29:29.590]                         envir <- sys.frame(frame)
[01:29:29.590]                       }
[01:29:29.590]                     }
[01:29:29.590]                     sendCondition <<- function(cond) NULL
[01:29:29.590]                   }
[01:29:29.590]                 })
[01:29:29.590]                 withCallingHandlers({
[01:29:29.590]                   {
[01:29:29.590]                     sample(x, size = 1L)
[01:29:29.590]                   }
[01:29:29.590]                 }, immediateCondition = function(cond) {
[01:29:29.590]                   sendCondition <- ...future.makeSendCondition()
[01:29:29.590]                   sendCondition(cond)
[01:29:29.590]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.590]                   {
[01:29:29.590]                     inherits <- base::inherits
[01:29:29.590]                     invokeRestart <- base::invokeRestart
[01:29:29.590]                     is.null <- base::is.null
[01:29:29.590]                     muffled <- FALSE
[01:29:29.590]                     if (inherits(cond, "message")) {
[01:29:29.590]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:29.590]                       if (muffled) 
[01:29:29.590]                         invokeRestart("muffleMessage")
[01:29:29.590]                     }
[01:29:29.590]                     else if (inherits(cond, "warning")) {
[01:29:29.590]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:29.590]                       if (muffled) 
[01:29:29.590]                         invokeRestart("muffleWarning")
[01:29:29.590]                     }
[01:29:29.590]                     else if (inherits(cond, "condition")) {
[01:29:29.590]                       if (!is.null(pattern)) {
[01:29:29.590]                         computeRestarts <- base::computeRestarts
[01:29:29.590]                         grepl <- base::grepl
[01:29:29.590]                         restarts <- computeRestarts(cond)
[01:29:29.590]                         for (restart in restarts) {
[01:29:29.590]                           name <- restart$name
[01:29:29.590]                           if (is.null(name)) 
[01:29:29.590]                             next
[01:29:29.590]                           if (!grepl(pattern, name)) 
[01:29:29.590]                             next
[01:29:29.590]                           invokeRestart(restart)
[01:29:29.590]                           muffled <- TRUE
[01:29:29.590]                           break
[01:29:29.590]                         }
[01:29:29.590]                       }
[01:29:29.590]                     }
[01:29:29.590]                     invisible(muffled)
[01:29:29.590]                   }
[01:29:29.590]                   muffleCondition(cond)
[01:29:29.590]                 })
[01:29:29.590]             }))
[01:29:29.590]             future::FutureResult(value = ...future.value$value, 
[01:29:29.590]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:29.590]                   ...future.rng), globalenv = if (FALSE) 
[01:29:29.590]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:29.590]                     ...future.globalenv.names))
[01:29:29.590]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:29.590]         }, condition = base::local({
[01:29:29.590]             c <- base::c
[01:29:29.590]             inherits <- base::inherits
[01:29:29.590]             invokeRestart <- base::invokeRestart
[01:29:29.590]             length <- base::length
[01:29:29.590]             list <- base::list
[01:29:29.590]             seq.int <- base::seq.int
[01:29:29.590]             signalCondition <- base::signalCondition
[01:29:29.590]             sys.calls <- base::sys.calls
[01:29:29.590]             `[[` <- base::`[[`
[01:29:29.590]             `+` <- base::`+`
[01:29:29.590]             `<<-` <- base::`<<-`
[01:29:29.590]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:29.590]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:29.590]                   3L)]
[01:29:29.590]             }
[01:29:29.590]             function(cond) {
[01:29:29.590]                 is_error <- inherits(cond, "error")
[01:29:29.590]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:29.590]                   NULL)
[01:29:29.590]                 if (is_error) {
[01:29:29.590]                   sessionInformation <- function() {
[01:29:29.590]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:29.590]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:29.590]                       search = base::search(), system = base::Sys.info())
[01:29:29.590]                   }
[01:29:29.590]                   ...future.conditions[[length(...future.conditions) + 
[01:29:29.590]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:29.590]                     cond$call), session = sessionInformation(), 
[01:29:29.590]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:29.590]                   signalCondition(cond)
[01:29:29.590]                 }
[01:29:29.590]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:29.590]                 "immediateCondition"))) {
[01:29:29.590]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:29.590]                   ...future.conditions[[length(...future.conditions) + 
[01:29:29.590]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:29.590]                   if (TRUE && !signal) {
[01:29:29.590]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.590]                     {
[01:29:29.590]                       inherits <- base::inherits
[01:29:29.590]                       invokeRestart <- base::invokeRestart
[01:29:29.590]                       is.null <- base::is.null
[01:29:29.590]                       muffled <- FALSE
[01:29:29.590]                       if (inherits(cond, "message")) {
[01:29:29.590]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:29.590]                         if (muffled) 
[01:29:29.590]                           invokeRestart("muffleMessage")
[01:29:29.590]                       }
[01:29:29.590]                       else if (inherits(cond, "warning")) {
[01:29:29.590]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:29.590]                         if (muffled) 
[01:29:29.590]                           invokeRestart("muffleWarning")
[01:29:29.590]                       }
[01:29:29.590]                       else if (inherits(cond, "condition")) {
[01:29:29.590]                         if (!is.null(pattern)) {
[01:29:29.590]                           computeRestarts <- base::computeRestarts
[01:29:29.590]                           grepl <- base::grepl
[01:29:29.590]                           restarts <- computeRestarts(cond)
[01:29:29.590]                           for (restart in restarts) {
[01:29:29.590]                             name <- restart$name
[01:29:29.590]                             if (is.null(name)) 
[01:29:29.590]                               next
[01:29:29.590]                             if (!grepl(pattern, name)) 
[01:29:29.590]                               next
[01:29:29.590]                             invokeRestart(restart)
[01:29:29.590]                             muffled <- TRUE
[01:29:29.590]                             break
[01:29:29.590]                           }
[01:29:29.590]                         }
[01:29:29.590]                       }
[01:29:29.590]                       invisible(muffled)
[01:29:29.590]                     }
[01:29:29.590]                     muffleCondition(cond, pattern = "^muffle")
[01:29:29.590]                   }
[01:29:29.590]                 }
[01:29:29.590]                 else {
[01:29:29.590]                   if (TRUE) {
[01:29:29.590]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.590]                     {
[01:29:29.590]                       inherits <- base::inherits
[01:29:29.590]                       invokeRestart <- base::invokeRestart
[01:29:29.590]                       is.null <- base::is.null
[01:29:29.590]                       muffled <- FALSE
[01:29:29.590]                       if (inherits(cond, "message")) {
[01:29:29.590]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:29.590]                         if (muffled) 
[01:29:29.590]                           invokeRestart("muffleMessage")
[01:29:29.590]                       }
[01:29:29.590]                       else if (inherits(cond, "warning")) {
[01:29:29.590]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:29.590]                         if (muffled) 
[01:29:29.590]                           invokeRestart("muffleWarning")
[01:29:29.590]                       }
[01:29:29.590]                       else if (inherits(cond, "condition")) {
[01:29:29.590]                         if (!is.null(pattern)) {
[01:29:29.590]                           computeRestarts <- base::computeRestarts
[01:29:29.590]                           grepl <- base::grepl
[01:29:29.590]                           restarts <- computeRestarts(cond)
[01:29:29.590]                           for (restart in restarts) {
[01:29:29.590]                             name <- restart$name
[01:29:29.590]                             if (is.null(name)) 
[01:29:29.590]                               next
[01:29:29.590]                             if (!grepl(pattern, name)) 
[01:29:29.590]                               next
[01:29:29.590]                             invokeRestart(restart)
[01:29:29.590]                             muffled <- TRUE
[01:29:29.590]                             break
[01:29:29.590]                           }
[01:29:29.590]                         }
[01:29:29.590]                       }
[01:29:29.590]                       invisible(muffled)
[01:29:29.590]                     }
[01:29:29.590]                     muffleCondition(cond, pattern = "^muffle")
[01:29:29.590]                   }
[01:29:29.590]                 }
[01:29:29.590]             }
[01:29:29.590]         }))
[01:29:29.590]     }, error = function(ex) {
[01:29:29.590]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:29.590]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:29.590]                 ...future.rng), started = ...future.startTime, 
[01:29:29.590]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:29.590]             version = "1.8"), class = "FutureResult")
[01:29:29.590]     }, finally = {
[01:29:29.590]         if (!identical(...future.workdir, getwd())) 
[01:29:29.590]             setwd(...future.workdir)
[01:29:29.590]         {
[01:29:29.590]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:29.590]                 ...future.oldOptions$nwarnings <- NULL
[01:29:29.590]             }
[01:29:29.590]             base::options(...future.oldOptions)
[01:29:29.590]             if (.Platform$OS.type == "windows") {
[01:29:29.590]                 old_names <- names(...future.oldEnvVars)
[01:29:29.590]                 envs <- base::Sys.getenv()
[01:29:29.590]                 names <- names(envs)
[01:29:29.590]                 common <- intersect(names, old_names)
[01:29:29.590]                 added <- setdiff(names, old_names)
[01:29:29.590]                 removed <- setdiff(old_names, names)
[01:29:29.590]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:29.590]                   envs[common]]
[01:29:29.590]                 NAMES <- toupper(changed)
[01:29:29.590]                 args <- list()
[01:29:29.590]                 for (kk in seq_along(NAMES)) {
[01:29:29.590]                   name <- changed[[kk]]
[01:29:29.590]                   NAME <- NAMES[[kk]]
[01:29:29.590]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.590]                     next
[01:29:29.590]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:29.590]                 }
[01:29:29.590]                 NAMES <- toupper(added)
[01:29:29.590]                 for (kk in seq_along(NAMES)) {
[01:29:29.590]                   name <- added[[kk]]
[01:29:29.590]                   NAME <- NAMES[[kk]]
[01:29:29.590]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.590]                     next
[01:29:29.590]                   args[[name]] <- ""
[01:29:29.590]                 }
[01:29:29.590]                 NAMES <- toupper(removed)
[01:29:29.590]                 for (kk in seq_along(NAMES)) {
[01:29:29.590]                   name <- removed[[kk]]
[01:29:29.590]                   NAME <- NAMES[[kk]]
[01:29:29.590]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.590]                     next
[01:29:29.590]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:29.590]                 }
[01:29:29.590]                 if (length(args) > 0) 
[01:29:29.590]                   base::do.call(base::Sys.setenv, args = args)
[01:29:29.590]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:29.590]             }
[01:29:29.590]             else {
[01:29:29.590]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:29.590]             }
[01:29:29.590]             {
[01:29:29.590]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:29.590]                   0L) {
[01:29:29.590]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:29.590]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:29.590]                   base::options(opts)
[01:29:29.590]                 }
[01:29:29.590]                 {
[01:29:29.590]                   {
[01:29:29.590]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:29.590]                     NULL
[01:29:29.590]                   }
[01:29:29.590]                   options(future.plan = NULL)
[01:29:29.590]                   if (is.na(NA_character_)) 
[01:29:29.590]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:29.590]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:29.590]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:29.590]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:29.590]                     envir = parent.frame()) 
[01:29:29.590]                   {
[01:29:29.590]                     if (is.function(workers)) 
[01:29:29.590]                       workers <- workers()
[01:29:29.590]                     workers <- structure(as.integer(workers), 
[01:29:29.590]                       class = class(workers))
[01:29:29.590]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:29.590]                       workers >= 1)
[01:29:29.590]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:29.590]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:29.590]                     }
[01:29:29.590]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:29.590]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:29.590]                       envir = envir)
[01:29:29.590]                     if (!future$lazy) 
[01:29:29.590]                       future <- run(future)
[01:29:29.590]                     invisible(future)
[01:29:29.590]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:29.590]                 }
[01:29:29.590]             }
[01:29:29.590]         }
[01:29:29.590]     })
[01:29:29.590]     if (TRUE) {
[01:29:29.590]         base::sink(type = "output", split = FALSE)
[01:29:29.590]         if (TRUE) {
[01:29:29.590]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:29.590]         }
[01:29:29.590]         else {
[01:29:29.590]             ...future.result["stdout"] <- base::list(NULL)
[01:29:29.590]         }
[01:29:29.590]         base::close(...future.stdout)
[01:29:29.590]         ...future.stdout <- NULL
[01:29:29.590]     }
[01:29:29.590]     ...future.result$conditions <- ...future.conditions
[01:29:29.590]     ...future.result$finished <- base::Sys.time()
[01:29:29.590]     ...future.result
[01:29:29.590] }
[01:29:29.596] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:29.596] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:29.597] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:29.597] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:29.598] MultisessionFuture started
[01:29:29.598] - Launch lazy future ... done
[01:29:29.598] run() for 'MultisessionFuture' ... done
[01:29:29.599] getGlobalsAndPackages() ...
[01:29:29.599] Searching for globals...
[01:29:29.600] - globals found: [3] '{', 'sample', 'x'
[01:29:29.601] Searching for globals ... DONE
[01:29:29.601] Resolving globals: FALSE
[01:29:29.601] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:29.602] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:29.602] - globals: [1] 'x'
[01:29:29.602] 
[01:29:29.603] getGlobalsAndPackages() ... DONE
[01:29:29.603] run() for 'Future' ...
[01:29:29.603] - state: 'created'
[01:29:29.603] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:29.618] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:29.619] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:29.619]   - Field: 'node'
[01:29:29.619]   - Field: 'label'
[01:29:29.619]   - Field: 'local'
[01:29:29.619]   - Field: 'owner'
[01:29:29.620]   - Field: 'envir'
[01:29:29.620]   - Field: 'workers'
[01:29:29.620]   - Field: 'packages'
[01:29:29.620]   - Field: 'gc'
[01:29:29.620]   - Field: 'conditions'
[01:29:29.621]   - Field: 'persistent'
[01:29:29.621]   - Field: 'expr'
[01:29:29.621]   - Field: 'uuid'
[01:29:29.621]   - Field: 'seed'
[01:29:29.621]   - Field: 'version'
[01:29:29.622]   - Field: 'result'
[01:29:29.622]   - Field: 'asynchronous'
[01:29:29.622]   - Field: 'calls'
[01:29:29.622]   - Field: 'globals'
[01:29:29.622]   - Field: 'stdout'
[01:29:29.623]   - Field: 'earlySignal'
[01:29:29.623]   - Field: 'lazy'
[01:29:29.623]   - Field: 'state'
[01:29:29.623] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:29.623] - Launch lazy future ...
[01:29:29.624] Packages needed by the future expression (n = 0): <none>
[01:29:29.624] Packages needed by future strategies (n = 0): <none>
[01:29:29.625] {
[01:29:29.625]     {
[01:29:29.625]         {
[01:29:29.625]             ...future.startTime <- base::Sys.time()
[01:29:29.625]             {
[01:29:29.625]                 {
[01:29:29.625]                   {
[01:29:29.625]                     {
[01:29:29.625]                       {
[01:29:29.625]                         base::local({
[01:29:29.625]                           has_future <- base::requireNamespace("future", 
[01:29:29.625]                             quietly = TRUE)
[01:29:29.625]                           if (has_future) {
[01:29:29.625]                             ns <- base::getNamespace("future")
[01:29:29.625]                             version <- ns[[".package"]][["version"]]
[01:29:29.625]                             if (is.null(version)) 
[01:29:29.625]                               version <- utils::packageVersion("future")
[01:29:29.625]                           }
[01:29:29.625]                           else {
[01:29:29.625]                             version <- NULL
[01:29:29.625]                           }
[01:29:29.625]                           if (!has_future || version < "1.8.0") {
[01:29:29.625]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:29.625]                               "", base::R.version$version.string), 
[01:29:29.625]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:29.625]                                 base::R.version$platform, 8 * 
[01:29:29.625]                                   base::.Machine$sizeof.pointer), 
[01:29:29.625]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:29.625]                                 "release", "version")], collapse = " "), 
[01:29:29.625]                               hostname = base::Sys.info()[["nodename"]])
[01:29:29.625]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:29.625]                               info)
[01:29:29.625]                             info <- base::paste(info, collapse = "; ")
[01:29:29.625]                             if (!has_future) {
[01:29:29.625]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:29.625]                                 info)
[01:29:29.625]                             }
[01:29:29.625]                             else {
[01:29:29.625]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:29.625]                                 info, version)
[01:29:29.625]                             }
[01:29:29.625]                             base::stop(msg)
[01:29:29.625]                           }
[01:29:29.625]                         })
[01:29:29.625]                       }
[01:29:29.625]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:29.625]                       base::options(mc.cores = 1L)
[01:29:29.625]                     }
[01:29:29.625]                     options(future.plan = NULL)
[01:29:29.625]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:29.625]                     future::plan("default", .cleanup = FALSE, 
[01:29:29.625]                       .init = FALSE)
[01:29:29.625]                   }
[01:29:29.625]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[01:29:29.625]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[01:29:29.625]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[01:29:29.625]                 }
[01:29:29.625]                 ...future.workdir <- getwd()
[01:29:29.625]             }
[01:29:29.625]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:29.625]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:29.625]         }
[01:29:29.625]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:29.625]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:29.625]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:29.625]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:29.625]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:29.625]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:29.625]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:29.625]             base::names(...future.oldOptions))
[01:29:29.625]     }
[01:29:29.625]     if (FALSE) {
[01:29:29.625]     }
[01:29:29.625]     else {
[01:29:29.625]         if (TRUE) {
[01:29:29.625]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:29.625]                 open = "w")
[01:29:29.625]         }
[01:29:29.625]         else {
[01:29:29.625]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:29.625]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:29.625]         }
[01:29:29.625]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:29.625]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:29.625]             base::sink(type = "output", split = FALSE)
[01:29:29.625]             base::close(...future.stdout)
[01:29:29.625]         }, add = TRUE)
[01:29:29.625]     }
[01:29:29.625]     ...future.frame <- base::sys.nframe()
[01:29:29.625]     ...future.conditions <- base::list()
[01:29:29.625]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:29.625]     if (FALSE) {
[01:29:29.625]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:29.625]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:29.625]     }
[01:29:29.625]     ...future.result <- base::tryCatch({
[01:29:29.625]         base::withCallingHandlers({
[01:29:29.625]             ...future.value <- base::withVisible(base::local({
[01:29:29.625]                 ...future.makeSendCondition <- base::local({
[01:29:29.625]                   sendCondition <- NULL
[01:29:29.625]                   function(frame = 1L) {
[01:29:29.625]                     if (is.function(sendCondition)) 
[01:29:29.625]                       return(sendCondition)
[01:29:29.625]                     ns <- getNamespace("parallel")
[01:29:29.625]                     if (exists("sendData", mode = "function", 
[01:29:29.625]                       envir = ns)) {
[01:29:29.625]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:29.625]                         envir = ns)
[01:29:29.625]                       envir <- sys.frame(frame)
[01:29:29.625]                       master <- NULL
[01:29:29.625]                       while (!identical(envir, .GlobalEnv) && 
[01:29:29.625]                         !identical(envir, emptyenv())) {
[01:29:29.625]                         if (exists("master", mode = "list", envir = envir, 
[01:29:29.625]                           inherits = FALSE)) {
[01:29:29.625]                           master <- get("master", mode = "list", 
[01:29:29.625]                             envir = envir, inherits = FALSE)
[01:29:29.625]                           if (inherits(master, c("SOCKnode", 
[01:29:29.625]                             "SOCK0node"))) {
[01:29:29.625]                             sendCondition <<- function(cond) {
[01:29:29.625]                               data <- list(type = "VALUE", value = cond, 
[01:29:29.625]                                 success = TRUE)
[01:29:29.625]                               parallel_sendData(master, data)
[01:29:29.625]                             }
[01:29:29.625]                             return(sendCondition)
[01:29:29.625]                           }
[01:29:29.625]                         }
[01:29:29.625]                         frame <- frame + 1L
[01:29:29.625]                         envir <- sys.frame(frame)
[01:29:29.625]                       }
[01:29:29.625]                     }
[01:29:29.625]                     sendCondition <<- function(cond) NULL
[01:29:29.625]                   }
[01:29:29.625]                 })
[01:29:29.625]                 withCallingHandlers({
[01:29:29.625]                   {
[01:29:29.625]                     sample(x, size = 1L)
[01:29:29.625]                   }
[01:29:29.625]                 }, immediateCondition = function(cond) {
[01:29:29.625]                   sendCondition <- ...future.makeSendCondition()
[01:29:29.625]                   sendCondition(cond)
[01:29:29.625]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.625]                   {
[01:29:29.625]                     inherits <- base::inherits
[01:29:29.625]                     invokeRestart <- base::invokeRestart
[01:29:29.625]                     is.null <- base::is.null
[01:29:29.625]                     muffled <- FALSE
[01:29:29.625]                     if (inherits(cond, "message")) {
[01:29:29.625]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:29.625]                       if (muffled) 
[01:29:29.625]                         invokeRestart("muffleMessage")
[01:29:29.625]                     }
[01:29:29.625]                     else if (inherits(cond, "warning")) {
[01:29:29.625]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:29.625]                       if (muffled) 
[01:29:29.625]                         invokeRestart("muffleWarning")
[01:29:29.625]                     }
[01:29:29.625]                     else if (inherits(cond, "condition")) {
[01:29:29.625]                       if (!is.null(pattern)) {
[01:29:29.625]                         computeRestarts <- base::computeRestarts
[01:29:29.625]                         grepl <- base::grepl
[01:29:29.625]                         restarts <- computeRestarts(cond)
[01:29:29.625]                         for (restart in restarts) {
[01:29:29.625]                           name <- restart$name
[01:29:29.625]                           if (is.null(name)) 
[01:29:29.625]                             next
[01:29:29.625]                           if (!grepl(pattern, name)) 
[01:29:29.625]                             next
[01:29:29.625]                           invokeRestart(restart)
[01:29:29.625]                           muffled <- TRUE
[01:29:29.625]                           break
[01:29:29.625]                         }
[01:29:29.625]                       }
[01:29:29.625]                     }
[01:29:29.625]                     invisible(muffled)
[01:29:29.625]                   }
[01:29:29.625]                   muffleCondition(cond)
[01:29:29.625]                 })
[01:29:29.625]             }))
[01:29:29.625]             future::FutureResult(value = ...future.value$value, 
[01:29:29.625]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:29.625]                   ...future.rng), globalenv = if (FALSE) 
[01:29:29.625]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:29.625]                     ...future.globalenv.names))
[01:29:29.625]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:29.625]         }, condition = base::local({
[01:29:29.625]             c <- base::c
[01:29:29.625]             inherits <- base::inherits
[01:29:29.625]             invokeRestart <- base::invokeRestart
[01:29:29.625]             length <- base::length
[01:29:29.625]             list <- base::list
[01:29:29.625]             seq.int <- base::seq.int
[01:29:29.625]             signalCondition <- base::signalCondition
[01:29:29.625]             sys.calls <- base::sys.calls
[01:29:29.625]             `[[` <- base::`[[`
[01:29:29.625]             `+` <- base::`+`
[01:29:29.625]             `<<-` <- base::`<<-`
[01:29:29.625]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:29.625]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:29.625]                   3L)]
[01:29:29.625]             }
[01:29:29.625]             function(cond) {
[01:29:29.625]                 is_error <- inherits(cond, "error")
[01:29:29.625]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:29.625]                   NULL)
[01:29:29.625]                 if (is_error) {
[01:29:29.625]                   sessionInformation <- function() {
[01:29:29.625]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:29.625]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:29.625]                       search = base::search(), system = base::Sys.info())
[01:29:29.625]                   }
[01:29:29.625]                   ...future.conditions[[length(...future.conditions) + 
[01:29:29.625]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:29.625]                     cond$call), session = sessionInformation(), 
[01:29:29.625]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:29.625]                   signalCondition(cond)
[01:29:29.625]                 }
[01:29:29.625]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:29.625]                 "immediateCondition"))) {
[01:29:29.625]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:29.625]                   ...future.conditions[[length(...future.conditions) + 
[01:29:29.625]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:29.625]                   if (TRUE && !signal) {
[01:29:29.625]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.625]                     {
[01:29:29.625]                       inherits <- base::inherits
[01:29:29.625]                       invokeRestart <- base::invokeRestart
[01:29:29.625]                       is.null <- base::is.null
[01:29:29.625]                       muffled <- FALSE
[01:29:29.625]                       if (inherits(cond, "message")) {
[01:29:29.625]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:29.625]                         if (muffled) 
[01:29:29.625]                           invokeRestart("muffleMessage")
[01:29:29.625]                       }
[01:29:29.625]                       else if (inherits(cond, "warning")) {
[01:29:29.625]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:29.625]                         if (muffled) 
[01:29:29.625]                           invokeRestart("muffleWarning")
[01:29:29.625]                       }
[01:29:29.625]                       else if (inherits(cond, "condition")) {
[01:29:29.625]                         if (!is.null(pattern)) {
[01:29:29.625]                           computeRestarts <- base::computeRestarts
[01:29:29.625]                           grepl <- base::grepl
[01:29:29.625]                           restarts <- computeRestarts(cond)
[01:29:29.625]                           for (restart in restarts) {
[01:29:29.625]                             name <- restart$name
[01:29:29.625]                             if (is.null(name)) 
[01:29:29.625]                               next
[01:29:29.625]                             if (!grepl(pattern, name)) 
[01:29:29.625]                               next
[01:29:29.625]                             invokeRestart(restart)
[01:29:29.625]                             muffled <- TRUE
[01:29:29.625]                             break
[01:29:29.625]                           }
[01:29:29.625]                         }
[01:29:29.625]                       }
[01:29:29.625]                       invisible(muffled)
[01:29:29.625]                     }
[01:29:29.625]                     muffleCondition(cond, pattern = "^muffle")
[01:29:29.625]                   }
[01:29:29.625]                 }
[01:29:29.625]                 else {
[01:29:29.625]                   if (TRUE) {
[01:29:29.625]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.625]                     {
[01:29:29.625]                       inherits <- base::inherits
[01:29:29.625]                       invokeRestart <- base::invokeRestart
[01:29:29.625]                       is.null <- base::is.null
[01:29:29.625]                       muffled <- FALSE
[01:29:29.625]                       if (inherits(cond, "message")) {
[01:29:29.625]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:29.625]                         if (muffled) 
[01:29:29.625]                           invokeRestart("muffleMessage")
[01:29:29.625]                       }
[01:29:29.625]                       else if (inherits(cond, "warning")) {
[01:29:29.625]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:29.625]                         if (muffled) 
[01:29:29.625]                           invokeRestart("muffleWarning")
[01:29:29.625]                       }
[01:29:29.625]                       else if (inherits(cond, "condition")) {
[01:29:29.625]                         if (!is.null(pattern)) {
[01:29:29.625]                           computeRestarts <- base::computeRestarts
[01:29:29.625]                           grepl <- base::grepl
[01:29:29.625]                           restarts <- computeRestarts(cond)
[01:29:29.625]                           for (restart in restarts) {
[01:29:29.625]                             name <- restart$name
[01:29:29.625]                             if (is.null(name)) 
[01:29:29.625]                               next
[01:29:29.625]                             if (!grepl(pattern, name)) 
[01:29:29.625]                               next
[01:29:29.625]                             invokeRestart(restart)
[01:29:29.625]                             muffled <- TRUE
[01:29:29.625]                             break
[01:29:29.625]                           }
[01:29:29.625]                         }
[01:29:29.625]                       }
[01:29:29.625]                       invisible(muffled)
[01:29:29.625]                     }
[01:29:29.625]                     muffleCondition(cond, pattern = "^muffle")
[01:29:29.625]                   }
[01:29:29.625]                 }
[01:29:29.625]             }
[01:29:29.625]         }))
[01:29:29.625]     }, error = function(ex) {
[01:29:29.625]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:29.625]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:29.625]                 ...future.rng), started = ...future.startTime, 
[01:29:29.625]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:29.625]             version = "1.8"), class = "FutureResult")
[01:29:29.625]     }, finally = {
[01:29:29.625]         if (!identical(...future.workdir, getwd())) 
[01:29:29.625]             setwd(...future.workdir)
[01:29:29.625]         {
[01:29:29.625]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:29.625]                 ...future.oldOptions$nwarnings <- NULL
[01:29:29.625]             }
[01:29:29.625]             base::options(...future.oldOptions)
[01:29:29.625]             if (.Platform$OS.type == "windows") {
[01:29:29.625]                 old_names <- names(...future.oldEnvVars)
[01:29:29.625]                 envs <- base::Sys.getenv()
[01:29:29.625]                 names <- names(envs)
[01:29:29.625]                 common <- intersect(names, old_names)
[01:29:29.625]                 added <- setdiff(names, old_names)
[01:29:29.625]                 removed <- setdiff(old_names, names)
[01:29:29.625]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:29.625]                   envs[common]]
[01:29:29.625]                 NAMES <- toupper(changed)
[01:29:29.625]                 args <- list()
[01:29:29.625]                 for (kk in seq_along(NAMES)) {
[01:29:29.625]                   name <- changed[[kk]]
[01:29:29.625]                   NAME <- NAMES[[kk]]
[01:29:29.625]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.625]                     next
[01:29:29.625]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:29.625]                 }
[01:29:29.625]                 NAMES <- toupper(added)
[01:29:29.625]                 for (kk in seq_along(NAMES)) {
[01:29:29.625]                   name <- added[[kk]]
[01:29:29.625]                   NAME <- NAMES[[kk]]
[01:29:29.625]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.625]                     next
[01:29:29.625]                   args[[name]] <- ""
[01:29:29.625]                 }
[01:29:29.625]                 NAMES <- toupper(removed)
[01:29:29.625]                 for (kk in seq_along(NAMES)) {
[01:29:29.625]                   name <- removed[[kk]]
[01:29:29.625]                   NAME <- NAMES[[kk]]
[01:29:29.625]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.625]                     next
[01:29:29.625]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:29.625]                 }
[01:29:29.625]                 if (length(args) > 0) 
[01:29:29.625]                   base::do.call(base::Sys.setenv, args = args)
[01:29:29.625]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:29.625]             }
[01:29:29.625]             else {
[01:29:29.625]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:29.625]             }
[01:29:29.625]             {
[01:29:29.625]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:29.625]                   0L) {
[01:29:29.625]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:29.625]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:29.625]                   base::options(opts)
[01:29:29.625]                 }
[01:29:29.625]                 {
[01:29:29.625]                   {
[01:29:29.625]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:29.625]                     NULL
[01:29:29.625]                   }
[01:29:29.625]                   options(future.plan = NULL)
[01:29:29.625]                   if (is.na(NA_character_)) 
[01:29:29.625]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:29.625]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:29.625]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:29.625]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:29.625]                     envir = parent.frame()) 
[01:29:29.625]                   {
[01:29:29.625]                     if (is.function(workers)) 
[01:29:29.625]                       workers <- workers()
[01:29:29.625]                     workers <- structure(as.integer(workers), 
[01:29:29.625]                       class = class(workers))
[01:29:29.625]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:29.625]                       workers >= 1)
[01:29:29.625]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:29.625]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:29.625]                     }
[01:29:29.625]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:29.625]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:29.625]                       envir = envir)
[01:29:29.625]                     if (!future$lazy) 
[01:29:29.625]                       future <- run(future)
[01:29:29.625]                     invisible(future)
[01:29:29.625]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:29.625]                 }
[01:29:29.625]             }
[01:29:29.625]         }
[01:29:29.625]     })
[01:29:29.625]     if (TRUE) {
[01:29:29.625]         base::sink(type = "output", split = FALSE)
[01:29:29.625]         if (TRUE) {
[01:29:29.625]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:29.625]         }
[01:29:29.625]         else {
[01:29:29.625]             ...future.result["stdout"] <- base::list(NULL)
[01:29:29.625]         }
[01:29:29.625]         base::close(...future.stdout)
[01:29:29.625]         ...future.stdout <- NULL
[01:29:29.625]     }
[01:29:29.625]     ...future.result$conditions <- ...future.conditions
[01:29:29.625]     ...future.result$finished <- base::Sys.time()
[01:29:29.625]     ...future.result
[01:29:29.625] }
[01:29:29.711] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:29.711] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:29.712] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:29.712] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:29.713] MultisessionFuture started
[01:29:29.713] - Launch lazy future ... done
[01:29:29.713] run() for 'MultisessionFuture' ... done
[01:29:29.714] getGlobalsAndPackages() ...
[01:29:29.714] Searching for globals...
[01:29:29.716] - globals found: [3] '{', 'sample', 'x'
[01:29:29.716] Searching for globals ... DONE
[01:29:29.716] Resolving globals: FALSE
[01:29:29.717] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:29.717] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:29.718] - globals: [1] 'x'
[01:29:29.718] 
[01:29:29.718] getGlobalsAndPackages() ... DONE
[01:29:29.718] run() for 'Future' ...
[01:29:29.719] - state: 'created'
[01:29:29.719] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:29.735] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:29.735] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:29.735]   - Field: 'node'
[01:29:29.735]   - Field: 'label'
[01:29:29.736]   - Field: 'local'
[01:29:29.736]   - Field: 'owner'
[01:29:29.736]   - Field: 'envir'
[01:29:29.736]   - Field: 'workers'
[01:29:29.736]   - Field: 'packages'
[01:29:29.737]   - Field: 'gc'
[01:29:29.737]   - Field: 'conditions'
[01:29:29.737]   - Field: 'persistent'
[01:29:29.737]   - Field: 'expr'
[01:29:29.737]   - Field: 'uuid'
[01:29:29.738]   - Field: 'seed'
[01:29:29.738]   - Field: 'version'
[01:29:29.738]   - Field: 'result'
[01:29:29.738]   - Field: 'asynchronous'
[01:29:29.738]   - Field: 'calls'
[01:29:29.739]   - Field: 'globals'
[01:29:29.739]   - Field: 'stdout'
[01:29:29.739]   - Field: 'earlySignal'
[01:29:29.739]   - Field: 'lazy'
[01:29:29.739]   - Field: 'state'
[01:29:29.740] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:29.740] - Launch lazy future ...
[01:29:29.740] Packages needed by the future expression (n = 0): <none>
[01:29:29.741] Packages needed by future strategies (n = 0): <none>
[01:29:29.741] {
[01:29:29.741]     {
[01:29:29.741]         {
[01:29:29.741]             ...future.startTime <- base::Sys.time()
[01:29:29.741]             {
[01:29:29.741]                 {
[01:29:29.741]                   {
[01:29:29.741]                     {
[01:29:29.741]                       {
[01:29:29.741]                         base::local({
[01:29:29.741]                           has_future <- base::requireNamespace("future", 
[01:29:29.741]                             quietly = TRUE)
[01:29:29.741]                           if (has_future) {
[01:29:29.741]                             ns <- base::getNamespace("future")
[01:29:29.741]                             version <- ns[[".package"]][["version"]]
[01:29:29.741]                             if (is.null(version)) 
[01:29:29.741]                               version <- utils::packageVersion("future")
[01:29:29.741]                           }
[01:29:29.741]                           else {
[01:29:29.741]                             version <- NULL
[01:29:29.741]                           }
[01:29:29.741]                           if (!has_future || version < "1.8.0") {
[01:29:29.741]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:29.741]                               "", base::R.version$version.string), 
[01:29:29.741]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:29.741]                                 base::R.version$platform, 8 * 
[01:29:29.741]                                   base::.Machine$sizeof.pointer), 
[01:29:29.741]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:29.741]                                 "release", "version")], collapse = " "), 
[01:29:29.741]                               hostname = base::Sys.info()[["nodename"]])
[01:29:29.741]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:29.741]                               info)
[01:29:29.741]                             info <- base::paste(info, collapse = "; ")
[01:29:29.741]                             if (!has_future) {
[01:29:29.741]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:29.741]                                 info)
[01:29:29.741]                             }
[01:29:29.741]                             else {
[01:29:29.741]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:29.741]                                 info, version)
[01:29:29.741]                             }
[01:29:29.741]                             base::stop(msg)
[01:29:29.741]                           }
[01:29:29.741]                         })
[01:29:29.741]                       }
[01:29:29.741]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:29.741]                       base::options(mc.cores = 1L)
[01:29:29.741]                     }
[01:29:29.741]                     options(future.plan = NULL)
[01:29:29.741]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:29.741]                     future::plan("default", .cleanup = FALSE, 
[01:29:29.741]                       .init = FALSE)
[01:29:29.741]                   }
[01:29:29.741]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[01:29:29.741]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[01:29:29.741]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[01:29:29.741]                 }
[01:29:29.741]                 ...future.workdir <- getwd()
[01:29:29.741]             }
[01:29:29.741]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:29.741]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:29.741]         }
[01:29:29.741]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:29.741]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:29.741]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:29.741]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:29.741]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:29.741]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:29.741]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:29.741]             base::names(...future.oldOptions))
[01:29:29.741]     }
[01:29:29.741]     if (FALSE) {
[01:29:29.741]     }
[01:29:29.741]     else {
[01:29:29.741]         if (TRUE) {
[01:29:29.741]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:29.741]                 open = "w")
[01:29:29.741]         }
[01:29:29.741]         else {
[01:29:29.741]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:29.741]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:29.741]         }
[01:29:29.741]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:29.741]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:29.741]             base::sink(type = "output", split = FALSE)
[01:29:29.741]             base::close(...future.stdout)
[01:29:29.741]         }, add = TRUE)
[01:29:29.741]     }
[01:29:29.741]     ...future.frame <- base::sys.nframe()
[01:29:29.741]     ...future.conditions <- base::list()
[01:29:29.741]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:29.741]     if (FALSE) {
[01:29:29.741]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:29.741]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:29.741]     }
[01:29:29.741]     ...future.result <- base::tryCatch({
[01:29:29.741]         base::withCallingHandlers({
[01:29:29.741]             ...future.value <- base::withVisible(base::local({
[01:29:29.741]                 ...future.makeSendCondition <- base::local({
[01:29:29.741]                   sendCondition <- NULL
[01:29:29.741]                   function(frame = 1L) {
[01:29:29.741]                     if (is.function(sendCondition)) 
[01:29:29.741]                       return(sendCondition)
[01:29:29.741]                     ns <- getNamespace("parallel")
[01:29:29.741]                     if (exists("sendData", mode = "function", 
[01:29:29.741]                       envir = ns)) {
[01:29:29.741]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:29.741]                         envir = ns)
[01:29:29.741]                       envir <- sys.frame(frame)
[01:29:29.741]                       master <- NULL
[01:29:29.741]                       while (!identical(envir, .GlobalEnv) && 
[01:29:29.741]                         !identical(envir, emptyenv())) {
[01:29:29.741]                         if (exists("master", mode = "list", envir = envir, 
[01:29:29.741]                           inherits = FALSE)) {
[01:29:29.741]                           master <- get("master", mode = "list", 
[01:29:29.741]                             envir = envir, inherits = FALSE)
[01:29:29.741]                           if (inherits(master, c("SOCKnode", 
[01:29:29.741]                             "SOCK0node"))) {
[01:29:29.741]                             sendCondition <<- function(cond) {
[01:29:29.741]                               data <- list(type = "VALUE", value = cond, 
[01:29:29.741]                                 success = TRUE)
[01:29:29.741]                               parallel_sendData(master, data)
[01:29:29.741]                             }
[01:29:29.741]                             return(sendCondition)
[01:29:29.741]                           }
[01:29:29.741]                         }
[01:29:29.741]                         frame <- frame + 1L
[01:29:29.741]                         envir <- sys.frame(frame)
[01:29:29.741]                       }
[01:29:29.741]                     }
[01:29:29.741]                     sendCondition <<- function(cond) NULL
[01:29:29.741]                   }
[01:29:29.741]                 })
[01:29:29.741]                 withCallingHandlers({
[01:29:29.741]                   {
[01:29:29.741]                     sample(x, size = 1L)
[01:29:29.741]                   }
[01:29:29.741]                 }, immediateCondition = function(cond) {
[01:29:29.741]                   sendCondition <- ...future.makeSendCondition()
[01:29:29.741]                   sendCondition(cond)
[01:29:29.741]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.741]                   {
[01:29:29.741]                     inherits <- base::inherits
[01:29:29.741]                     invokeRestart <- base::invokeRestart
[01:29:29.741]                     is.null <- base::is.null
[01:29:29.741]                     muffled <- FALSE
[01:29:29.741]                     if (inherits(cond, "message")) {
[01:29:29.741]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:29.741]                       if (muffled) 
[01:29:29.741]                         invokeRestart("muffleMessage")
[01:29:29.741]                     }
[01:29:29.741]                     else if (inherits(cond, "warning")) {
[01:29:29.741]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:29.741]                       if (muffled) 
[01:29:29.741]                         invokeRestart("muffleWarning")
[01:29:29.741]                     }
[01:29:29.741]                     else if (inherits(cond, "condition")) {
[01:29:29.741]                       if (!is.null(pattern)) {
[01:29:29.741]                         computeRestarts <- base::computeRestarts
[01:29:29.741]                         grepl <- base::grepl
[01:29:29.741]                         restarts <- computeRestarts(cond)
[01:29:29.741]                         for (restart in restarts) {
[01:29:29.741]                           name <- restart$name
[01:29:29.741]                           if (is.null(name)) 
[01:29:29.741]                             next
[01:29:29.741]                           if (!grepl(pattern, name)) 
[01:29:29.741]                             next
[01:29:29.741]                           invokeRestart(restart)
[01:29:29.741]                           muffled <- TRUE
[01:29:29.741]                           break
[01:29:29.741]                         }
[01:29:29.741]                       }
[01:29:29.741]                     }
[01:29:29.741]                     invisible(muffled)
[01:29:29.741]                   }
[01:29:29.741]                   muffleCondition(cond)
[01:29:29.741]                 })
[01:29:29.741]             }))
[01:29:29.741]             future::FutureResult(value = ...future.value$value, 
[01:29:29.741]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:29.741]                   ...future.rng), globalenv = if (FALSE) 
[01:29:29.741]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:29.741]                     ...future.globalenv.names))
[01:29:29.741]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:29.741]         }, condition = base::local({
[01:29:29.741]             c <- base::c
[01:29:29.741]             inherits <- base::inherits
[01:29:29.741]             invokeRestart <- base::invokeRestart
[01:29:29.741]             length <- base::length
[01:29:29.741]             list <- base::list
[01:29:29.741]             seq.int <- base::seq.int
[01:29:29.741]             signalCondition <- base::signalCondition
[01:29:29.741]             sys.calls <- base::sys.calls
[01:29:29.741]             `[[` <- base::`[[`
[01:29:29.741]             `+` <- base::`+`
[01:29:29.741]             `<<-` <- base::`<<-`
[01:29:29.741]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:29.741]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:29.741]                   3L)]
[01:29:29.741]             }
[01:29:29.741]             function(cond) {
[01:29:29.741]                 is_error <- inherits(cond, "error")
[01:29:29.741]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:29.741]                   NULL)
[01:29:29.741]                 if (is_error) {
[01:29:29.741]                   sessionInformation <- function() {
[01:29:29.741]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:29.741]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:29.741]                       search = base::search(), system = base::Sys.info())
[01:29:29.741]                   }
[01:29:29.741]                   ...future.conditions[[length(...future.conditions) + 
[01:29:29.741]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:29.741]                     cond$call), session = sessionInformation(), 
[01:29:29.741]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:29.741]                   signalCondition(cond)
[01:29:29.741]                 }
[01:29:29.741]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:29.741]                 "immediateCondition"))) {
[01:29:29.741]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:29.741]                   ...future.conditions[[length(...future.conditions) + 
[01:29:29.741]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:29.741]                   if (TRUE && !signal) {
[01:29:29.741]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.741]                     {
[01:29:29.741]                       inherits <- base::inherits
[01:29:29.741]                       invokeRestart <- base::invokeRestart
[01:29:29.741]                       is.null <- base::is.null
[01:29:29.741]                       muffled <- FALSE
[01:29:29.741]                       if (inherits(cond, "message")) {
[01:29:29.741]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:29.741]                         if (muffled) 
[01:29:29.741]                           invokeRestart("muffleMessage")
[01:29:29.741]                       }
[01:29:29.741]                       else if (inherits(cond, "warning")) {
[01:29:29.741]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:29.741]                         if (muffled) 
[01:29:29.741]                           invokeRestart("muffleWarning")
[01:29:29.741]                       }
[01:29:29.741]                       else if (inherits(cond, "condition")) {
[01:29:29.741]                         if (!is.null(pattern)) {
[01:29:29.741]                           computeRestarts <- base::computeRestarts
[01:29:29.741]                           grepl <- base::grepl
[01:29:29.741]                           restarts <- computeRestarts(cond)
[01:29:29.741]                           for (restart in restarts) {
[01:29:29.741]                             name <- restart$name
[01:29:29.741]                             if (is.null(name)) 
[01:29:29.741]                               next
[01:29:29.741]                             if (!grepl(pattern, name)) 
[01:29:29.741]                               next
[01:29:29.741]                             invokeRestart(restart)
[01:29:29.741]                             muffled <- TRUE
[01:29:29.741]                             break
[01:29:29.741]                           }
[01:29:29.741]                         }
[01:29:29.741]                       }
[01:29:29.741]                       invisible(muffled)
[01:29:29.741]                     }
[01:29:29.741]                     muffleCondition(cond, pattern = "^muffle")
[01:29:29.741]                   }
[01:29:29.741]                 }
[01:29:29.741]                 else {
[01:29:29.741]                   if (TRUE) {
[01:29:29.741]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.741]                     {
[01:29:29.741]                       inherits <- base::inherits
[01:29:29.741]                       invokeRestart <- base::invokeRestart
[01:29:29.741]                       is.null <- base::is.null
[01:29:29.741]                       muffled <- FALSE
[01:29:29.741]                       if (inherits(cond, "message")) {
[01:29:29.741]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:29.741]                         if (muffled) 
[01:29:29.741]                           invokeRestart("muffleMessage")
[01:29:29.741]                       }
[01:29:29.741]                       else if (inherits(cond, "warning")) {
[01:29:29.741]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:29.741]                         if (muffled) 
[01:29:29.741]                           invokeRestart("muffleWarning")
[01:29:29.741]                       }
[01:29:29.741]                       else if (inherits(cond, "condition")) {
[01:29:29.741]                         if (!is.null(pattern)) {
[01:29:29.741]                           computeRestarts <- base::computeRestarts
[01:29:29.741]                           grepl <- base::grepl
[01:29:29.741]                           restarts <- computeRestarts(cond)
[01:29:29.741]                           for (restart in restarts) {
[01:29:29.741]                             name <- restart$name
[01:29:29.741]                             if (is.null(name)) 
[01:29:29.741]                               next
[01:29:29.741]                             if (!grepl(pattern, name)) 
[01:29:29.741]                               next
[01:29:29.741]                             invokeRestart(restart)
[01:29:29.741]                             muffled <- TRUE
[01:29:29.741]                             break
[01:29:29.741]                           }
[01:29:29.741]                         }
[01:29:29.741]                       }
[01:29:29.741]                       invisible(muffled)
[01:29:29.741]                     }
[01:29:29.741]                     muffleCondition(cond, pattern = "^muffle")
[01:29:29.741]                   }
[01:29:29.741]                 }
[01:29:29.741]             }
[01:29:29.741]         }))
[01:29:29.741]     }, error = function(ex) {
[01:29:29.741]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:29.741]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:29.741]                 ...future.rng), started = ...future.startTime, 
[01:29:29.741]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:29.741]             version = "1.8"), class = "FutureResult")
[01:29:29.741]     }, finally = {
[01:29:29.741]         if (!identical(...future.workdir, getwd())) 
[01:29:29.741]             setwd(...future.workdir)
[01:29:29.741]         {
[01:29:29.741]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:29.741]                 ...future.oldOptions$nwarnings <- NULL
[01:29:29.741]             }
[01:29:29.741]             base::options(...future.oldOptions)
[01:29:29.741]             if (.Platform$OS.type == "windows") {
[01:29:29.741]                 old_names <- names(...future.oldEnvVars)
[01:29:29.741]                 envs <- base::Sys.getenv()
[01:29:29.741]                 names <- names(envs)
[01:29:29.741]                 common <- intersect(names, old_names)
[01:29:29.741]                 added <- setdiff(names, old_names)
[01:29:29.741]                 removed <- setdiff(old_names, names)
[01:29:29.741]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:29.741]                   envs[common]]
[01:29:29.741]                 NAMES <- toupper(changed)
[01:29:29.741]                 args <- list()
[01:29:29.741]                 for (kk in seq_along(NAMES)) {
[01:29:29.741]                   name <- changed[[kk]]
[01:29:29.741]                   NAME <- NAMES[[kk]]
[01:29:29.741]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.741]                     next
[01:29:29.741]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:29.741]                 }
[01:29:29.741]                 NAMES <- toupper(added)
[01:29:29.741]                 for (kk in seq_along(NAMES)) {
[01:29:29.741]                   name <- added[[kk]]
[01:29:29.741]                   NAME <- NAMES[[kk]]
[01:29:29.741]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.741]                     next
[01:29:29.741]                   args[[name]] <- ""
[01:29:29.741]                 }
[01:29:29.741]                 NAMES <- toupper(removed)
[01:29:29.741]                 for (kk in seq_along(NAMES)) {
[01:29:29.741]                   name <- removed[[kk]]
[01:29:29.741]                   NAME <- NAMES[[kk]]
[01:29:29.741]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.741]                     next
[01:29:29.741]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:29.741]                 }
[01:29:29.741]                 if (length(args) > 0) 
[01:29:29.741]                   base::do.call(base::Sys.setenv, args = args)
[01:29:29.741]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:29.741]             }
[01:29:29.741]             else {
[01:29:29.741]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:29.741]             }
[01:29:29.741]             {
[01:29:29.741]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:29.741]                   0L) {
[01:29:29.741]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:29.741]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:29.741]                   base::options(opts)
[01:29:29.741]                 }
[01:29:29.741]                 {
[01:29:29.741]                   {
[01:29:29.741]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:29.741]                     NULL
[01:29:29.741]                   }
[01:29:29.741]                   options(future.plan = NULL)
[01:29:29.741]                   if (is.na(NA_character_)) 
[01:29:29.741]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:29.741]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:29.741]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:29.741]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:29.741]                     envir = parent.frame()) 
[01:29:29.741]                   {
[01:29:29.741]                     if (is.function(workers)) 
[01:29:29.741]                       workers <- workers()
[01:29:29.741]                     workers <- structure(as.integer(workers), 
[01:29:29.741]                       class = class(workers))
[01:29:29.741]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:29.741]                       workers >= 1)
[01:29:29.741]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:29.741]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:29.741]                     }
[01:29:29.741]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:29.741]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:29.741]                       envir = envir)
[01:29:29.741]                     if (!future$lazy) 
[01:29:29.741]                       future <- run(future)
[01:29:29.741]                     invisible(future)
[01:29:29.741]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:29.741]                 }
[01:29:29.741]             }
[01:29:29.741]         }
[01:29:29.741]     })
[01:29:29.741]     if (TRUE) {
[01:29:29.741]         base::sink(type = "output", split = FALSE)
[01:29:29.741]         if (TRUE) {
[01:29:29.741]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:29.741]         }
[01:29:29.741]         else {
[01:29:29.741]             ...future.result["stdout"] <- base::list(NULL)
[01:29:29.741]         }
[01:29:29.741]         base::close(...future.stdout)
[01:29:29.741]         ...future.stdout <- NULL
[01:29:29.741]     }
[01:29:29.741]     ...future.result$conditions <- ...future.conditions
[01:29:29.741]     ...future.result$finished <- base::Sys.time()
[01:29:29.741]     ...future.result
[01:29:29.741] }
[01:29:29.746] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:29.768] receiveMessageFromWorker() for ClusterFuture ...
[01:29:29.769] - Validating connection of MultisessionFuture
[01:29:29.769] - received message: FutureResult
[01:29:29.769] - Received FutureResult
[01:29:29.769] - Erased future from FutureRegistry
[01:29:29.770] result() for ClusterFuture ...
[01:29:29.770] - result already collected: FutureResult
[01:29:29.770] result() for ClusterFuture ... done
[01:29:29.770] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:29.771] result() for ClusterFuture ...
[01:29:29.771] - result already collected: FutureResult
[01:29:29.771] result() for ClusterFuture ... done
[01:29:29.771] result() for ClusterFuture ...
[01:29:29.771] - result already collected: FutureResult
[01:29:29.771] result() for ClusterFuture ... done
[01:29:29.773] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:29.773] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:29.773] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:29.774] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:29.774] MultisessionFuture started
[01:29:29.775] - Launch lazy future ... done
[01:29:29.775] run() for 'MultisessionFuture' ... done
[01:29:29.775] getGlobalsAndPackages() ...
[01:29:29.775] Searching for globals...
[01:29:29.777] - globals found: [3] '{', 'sample', 'x'
[01:29:29.777] Searching for globals ... DONE
[01:29:29.777] Resolving globals: FALSE
[01:29:29.778] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:29.778] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:29.779] - globals: [1] 'x'
[01:29:29.782] 
[01:29:29.782] getGlobalsAndPackages() ... DONE
[01:29:29.782] run() for 'Future' ...
[01:29:29.782] - state: 'created'
[01:29:29.783] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:29.797] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:29.797] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:29.798]   - Field: 'node'
[01:29:29.798]   - Field: 'label'
[01:29:29.798]   - Field: 'local'
[01:29:29.798]   - Field: 'owner'
[01:29:29.798]   - Field: 'envir'
[01:29:29.798]   - Field: 'workers'
[01:29:29.799]   - Field: 'packages'
[01:29:29.799]   - Field: 'gc'
[01:29:29.799]   - Field: 'conditions'
[01:29:29.799]   - Field: 'persistent'
[01:29:29.799]   - Field: 'expr'
[01:29:29.800]   - Field: 'uuid'
[01:29:29.800]   - Field: 'seed'
[01:29:29.800]   - Field: 'version'
[01:29:29.800]   - Field: 'result'
[01:29:29.800]   - Field: 'asynchronous'
[01:29:29.800]   - Field: 'calls'
[01:29:29.801]   - Field: 'globals'
[01:29:29.801]   - Field: 'stdout'
[01:29:29.801]   - Field: 'earlySignal'
[01:29:29.801]   - Field: 'lazy'
[01:29:29.801]   - Field: 'state'
[01:29:29.802] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:29.802] - Launch lazy future ...
[01:29:29.802] Packages needed by the future expression (n = 0): <none>
[01:29:29.802] Packages needed by future strategies (n = 0): <none>
[01:29:29.803] {
[01:29:29.803]     {
[01:29:29.803]         {
[01:29:29.803]             ...future.startTime <- base::Sys.time()
[01:29:29.803]             {
[01:29:29.803]                 {
[01:29:29.803]                   {
[01:29:29.803]                     {
[01:29:29.803]                       {
[01:29:29.803]                         base::local({
[01:29:29.803]                           has_future <- base::requireNamespace("future", 
[01:29:29.803]                             quietly = TRUE)
[01:29:29.803]                           if (has_future) {
[01:29:29.803]                             ns <- base::getNamespace("future")
[01:29:29.803]                             version <- ns[[".package"]][["version"]]
[01:29:29.803]                             if (is.null(version)) 
[01:29:29.803]                               version <- utils::packageVersion("future")
[01:29:29.803]                           }
[01:29:29.803]                           else {
[01:29:29.803]                             version <- NULL
[01:29:29.803]                           }
[01:29:29.803]                           if (!has_future || version < "1.8.0") {
[01:29:29.803]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:29.803]                               "", base::R.version$version.string), 
[01:29:29.803]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:29.803]                                 base::R.version$platform, 8 * 
[01:29:29.803]                                   base::.Machine$sizeof.pointer), 
[01:29:29.803]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:29.803]                                 "release", "version")], collapse = " "), 
[01:29:29.803]                               hostname = base::Sys.info()[["nodename"]])
[01:29:29.803]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:29.803]                               info)
[01:29:29.803]                             info <- base::paste(info, collapse = "; ")
[01:29:29.803]                             if (!has_future) {
[01:29:29.803]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:29.803]                                 info)
[01:29:29.803]                             }
[01:29:29.803]                             else {
[01:29:29.803]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:29.803]                                 info, version)
[01:29:29.803]                             }
[01:29:29.803]                             base::stop(msg)
[01:29:29.803]                           }
[01:29:29.803]                         })
[01:29:29.803]                       }
[01:29:29.803]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:29.803]                       base::options(mc.cores = 1L)
[01:29:29.803]                     }
[01:29:29.803]                     options(future.plan = NULL)
[01:29:29.803]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:29.803]                     future::plan("default", .cleanup = FALSE, 
[01:29:29.803]                       .init = FALSE)
[01:29:29.803]                   }
[01:29:29.803]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[01:29:29.803]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[01:29:29.803]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[01:29:29.803]                 }
[01:29:29.803]                 ...future.workdir <- getwd()
[01:29:29.803]             }
[01:29:29.803]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:29.803]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:29.803]         }
[01:29:29.803]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:29.803]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:29.803]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:29.803]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:29.803]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:29.803]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:29.803]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:29.803]             base::names(...future.oldOptions))
[01:29:29.803]     }
[01:29:29.803]     if (FALSE) {
[01:29:29.803]     }
[01:29:29.803]     else {
[01:29:29.803]         if (TRUE) {
[01:29:29.803]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:29.803]                 open = "w")
[01:29:29.803]         }
[01:29:29.803]         else {
[01:29:29.803]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:29.803]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:29.803]         }
[01:29:29.803]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:29.803]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:29.803]             base::sink(type = "output", split = FALSE)
[01:29:29.803]             base::close(...future.stdout)
[01:29:29.803]         }, add = TRUE)
[01:29:29.803]     }
[01:29:29.803]     ...future.frame <- base::sys.nframe()
[01:29:29.803]     ...future.conditions <- base::list()
[01:29:29.803]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:29.803]     if (FALSE) {
[01:29:29.803]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:29.803]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:29.803]     }
[01:29:29.803]     ...future.result <- base::tryCatch({
[01:29:29.803]         base::withCallingHandlers({
[01:29:29.803]             ...future.value <- base::withVisible(base::local({
[01:29:29.803]                 ...future.makeSendCondition <- base::local({
[01:29:29.803]                   sendCondition <- NULL
[01:29:29.803]                   function(frame = 1L) {
[01:29:29.803]                     if (is.function(sendCondition)) 
[01:29:29.803]                       return(sendCondition)
[01:29:29.803]                     ns <- getNamespace("parallel")
[01:29:29.803]                     if (exists("sendData", mode = "function", 
[01:29:29.803]                       envir = ns)) {
[01:29:29.803]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:29.803]                         envir = ns)
[01:29:29.803]                       envir <- sys.frame(frame)
[01:29:29.803]                       master <- NULL
[01:29:29.803]                       while (!identical(envir, .GlobalEnv) && 
[01:29:29.803]                         !identical(envir, emptyenv())) {
[01:29:29.803]                         if (exists("master", mode = "list", envir = envir, 
[01:29:29.803]                           inherits = FALSE)) {
[01:29:29.803]                           master <- get("master", mode = "list", 
[01:29:29.803]                             envir = envir, inherits = FALSE)
[01:29:29.803]                           if (inherits(master, c("SOCKnode", 
[01:29:29.803]                             "SOCK0node"))) {
[01:29:29.803]                             sendCondition <<- function(cond) {
[01:29:29.803]                               data <- list(type = "VALUE", value = cond, 
[01:29:29.803]                                 success = TRUE)
[01:29:29.803]                               parallel_sendData(master, data)
[01:29:29.803]                             }
[01:29:29.803]                             return(sendCondition)
[01:29:29.803]                           }
[01:29:29.803]                         }
[01:29:29.803]                         frame <- frame + 1L
[01:29:29.803]                         envir <- sys.frame(frame)
[01:29:29.803]                       }
[01:29:29.803]                     }
[01:29:29.803]                     sendCondition <<- function(cond) NULL
[01:29:29.803]                   }
[01:29:29.803]                 })
[01:29:29.803]                 withCallingHandlers({
[01:29:29.803]                   {
[01:29:29.803]                     sample(x, size = 1L)
[01:29:29.803]                   }
[01:29:29.803]                 }, immediateCondition = function(cond) {
[01:29:29.803]                   sendCondition <- ...future.makeSendCondition()
[01:29:29.803]                   sendCondition(cond)
[01:29:29.803]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.803]                   {
[01:29:29.803]                     inherits <- base::inherits
[01:29:29.803]                     invokeRestart <- base::invokeRestart
[01:29:29.803]                     is.null <- base::is.null
[01:29:29.803]                     muffled <- FALSE
[01:29:29.803]                     if (inherits(cond, "message")) {
[01:29:29.803]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:29.803]                       if (muffled) 
[01:29:29.803]                         invokeRestart("muffleMessage")
[01:29:29.803]                     }
[01:29:29.803]                     else if (inherits(cond, "warning")) {
[01:29:29.803]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:29.803]                       if (muffled) 
[01:29:29.803]                         invokeRestart("muffleWarning")
[01:29:29.803]                     }
[01:29:29.803]                     else if (inherits(cond, "condition")) {
[01:29:29.803]                       if (!is.null(pattern)) {
[01:29:29.803]                         computeRestarts <- base::computeRestarts
[01:29:29.803]                         grepl <- base::grepl
[01:29:29.803]                         restarts <- computeRestarts(cond)
[01:29:29.803]                         for (restart in restarts) {
[01:29:29.803]                           name <- restart$name
[01:29:29.803]                           if (is.null(name)) 
[01:29:29.803]                             next
[01:29:29.803]                           if (!grepl(pattern, name)) 
[01:29:29.803]                             next
[01:29:29.803]                           invokeRestart(restart)
[01:29:29.803]                           muffled <- TRUE
[01:29:29.803]                           break
[01:29:29.803]                         }
[01:29:29.803]                       }
[01:29:29.803]                     }
[01:29:29.803]                     invisible(muffled)
[01:29:29.803]                   }
[01:29:29.803]                   muffleCondition(cond)
[01:29:29.803]                 })
[01:29:29.803]             }))
[01:29:29.803]             future::FutureResult(value = ...future.value$value, 
[01:29:29.803]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:29.803]                   ...future.rng), globalenv = if (FALSE) 
[01:29:29.803]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:29.803]                     ...future.globalenv.names))
[01:29:29.803]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:29.803]         }, condition = base::local({
[01:29:29.803]             c <- base::c
[01:29:29.803]             inherits <- base::inherits
[01:29:29.803]             invokeRestart <- base::invokeRestart
[01:29:29.803]             length <- base::length
[01:29:29.803]             list <- base::list
[01:29:29.803]             seq.int <- base::seq.int
[01:29:29.803]             signalCondition <- base::signalCondition
[01:29:29.803]             sys.calls <- base::sys.calls
[01:29:29.803]             `[[` <- base::`[[`
[01:29:29.803]             `+` <- base::`+`
[01:29:29.803]             `<<-` <- base::`<<-`
[01:29:29.803]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:29.803]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:29.803]                   3L)]
[01:29:29.803]             }
[01:29:29.803]             function(cond) {
[01:29:29.803]                 is_error <- inherits(cond, "error")
[01:29:29.803]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:29.803]                   NULL)
[01:29:29.803]                 if (is_error) {
[01:29:29.803]                   sessionInformation <- function() {
[01:29:29.803]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:29.803]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:29.803]                       search = base::search(), system = base::Sys.info())
[01:29:29.803]                   }
[01:29:29.803]                   ...future.conditions[[length(...future.conditions) + 
[01:29:29.803]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:29.803]                     cond$call), session = sessionInformation(), 
[01:29:29.803]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:29.803]                   signalCondition(cond)
[01:29:29.803]                 }
[01:29:29.803]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:29.803]                 "immediateCondition"))) {
[01:29:29.803]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:29.803]                   ...future.conditions[[length(...future.conditions) + 
[01:29:29.803]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:29.803]                   if (TRUE && !signal) {
[01:29:29.803]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.803]                     {
[01:29:29.803]                       inherits <- base::inherits
[01:29:29.803]                       invokeRestart <- base::invokeRestart
[01:29:29.803]                       is.null <- base::is.null
[01:29:29.803]                       muffled <- FALSE
[01:29:29.803]                       if (inherits(cond, "message")) {
[01:29:29.803]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:29.803]                         if (muffled) 
[01:29:29.803]                           invokeRestart("muffleMessage")
[01:29:29.803]                       }
[01:29:29.803]                       else if (inherits(cond, "warning")) {
[01:29:29.803]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:29.803]                         if (muffled) 
[01:29:29.803]                           invokeRestart("muffleWarning")
[01:29:29.803]                       }
[01:29:29.803]                       else if (inherits(cond, "condition")) {
[01:29:29.803]                         if (!is.null(pattern)) {
[01:29:29.803]                           computeRestarts <- base::computeRestarts
[01:29:29.803]                           grepl <- base::grepl
[01:29:29.803]                           restarts <- computeRestarts(cond)
[01:29:29.803]                           for (restart in restarts) {
[01:29:29.803]                             name <- restart$name
[01:29:29.803]                             if (is.null(name)) 
[01:29:29.803]                               next
[01:29:29.803]                             if (!grepl(pattern, name)) 
[01:29:29.803]                               next
[01:29:29.803]                             invokeRestart(restart)
[01:29:29.803]                             muffled <- TRUE
[01:29:29.803]                             break
[01:29:29.803]                           }
[01:29:29.803]                         }
[01:29:29.803]                       }
[01:29:29.803]                       invisible(muffled)
[01:29:29.803]                     }
[01:29:29.803]                     muffleCondition(cond, pattern = "^muffle")
[01:29:29.803]                   }
[01:29:29.803]                 }
[01:29:29.803]                 else {
[01:29:29.803]                   if (TRUE) {
[01:29:29.803]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.803]                     {
[01:29:29.803]                       inherits <- base::inherits
[01:29:29.803]                       invokeRestart <- base::invokeRestart
[01:29:29.803]                       is.null <- base::is.null
[01:29:29.803]                       muffled <- FALSE
[01:29:29.803]                       if (inherits(cond, "message")) {
[01:29:29.803]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:29.803]                         if (muffled) 
[01:29:29.803]                           invokeRestart("muffleMessage")
[01:29:29.803]                       }
[01:29:29.803]                       else if (inherits(cond, "warning")) {
[01:29:29.803]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:29.803]                         if (muffled) 
[01:29:29.803]                           invokeRestart("muffleWarning")
[01:29:29.803]                       }
[01:29:29.803]                       else if (inherits(cond, "condition")) {
[01:29:29.803]                         if (!is.null(pattern)) {
[01:29:29.803]                           computeRestarts <- base::computeRestarts
[01:29:29.803]                           grepl <- base::grepl
[01:29:29.803]                           restarts <- computeRestarts(cond)
[01:29:29.803]                           for (restart in restarts) {
[01:29:29.803]                             name <- restart$name
[01:29:29.803]                             if (is.null(name)) 
[01:29:29.803]                               next
[01:29:29.803]                             if (!grepl(pattern, name)) 
[01:29:29.803]                               next
[01:29:29.803]                             invokeRestart(restart)
[01:29:29.803]                             muffled <- TRUE
[01:29:29.803]                             break
[01:29:29.803]                           }
[01:29:29.803]                         }
[01:29:29.803]                       }
[01:29:29.803]                       invisible(muffled)
[01:29:29.803]                     }
[01:29:29.803]                     muffleCondition(cond, pattern = "^muffle")
[01:29:29.803]                   }
[01:29:29.803]                 }
[01:29:29.803]             }
[01:29:29.803]         }))
[01:29:29.803]     }, error = function(ex) {
[01:29:29.803]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:29.803]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:29.803]                 ...future.rng), started = ...future.startTime, 
[01:29:29.803]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:29.803]             version = "1.8"), class = "FutureResult")
[01:29:29.803]     }, finally = {
[01:29:29.803]         if (!identical(...future.workdir, getwd())) 
[01:29:29.803]             setwd(...future.workdir)
[01:29:29.803]         {
[01:29:29.803]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:29.803]                 ...future.oldOptions$nwarnings <- NULL
[01:29:29.803]             }
[01:29:29.803]             base::options(...future.oldOptions)
[01:29:29.803]             if (.Platform$OS.type == "windows") {
[01:29:29.803]                 old_names <- names(...future.oldEnvVars)
[01:29:29.803]                 envs <- base::Sys.getenv()
[01:29:29.803]                 names <- names(envs)
[01:29:29.803]                 common <- intersect(names, old_names)
[01:29:29.803]                 added <- setdiff(names, old_names)
[01:29:29.803]                 removed <- setdiff(old_names, names)
[01:29:29.803]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:29.803]                   envs[common]]
[01:29:29.803]                 NAMES <- toupper(changed)
[01:29:29.803]                 args <- list()
[01:29:29.803]                 for (kk in seq_along(NAMES)) {
[01:29:29.803]                   name <- changed[[kk]]
[01:29:29.803]                   NAME <- NAMES[[kk]]
[01:29:29.803]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.803]                     next
[01:29:29.803]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:29.803]                 }
[01:29:29.803]                 NAMES <- toupper(added)
[01:29:29.803]                 for (kk in seq_along(NAMES)) {
[01:29:29.803]                   name <- added[[kk]]
[01:29:29.803]                   NAME <- NAMES[[kk]]
[01:29:29.803]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.803]                     next
[01:29:29.803]                   args[[name]] <- ""
[01:29:29.803]                 }
[01:29:29.803]                 NAMES <- toupper(removed)
[01:29:29.803]                 for (kk in seq_along(NAMES)) {
[01:29:29.803]                   name <- removed[[kk]]
[01:29:29.803]                   NAME <- NAMES[[kk]]
[01:29:29.803]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.803]                     next
[01:29:29.803]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:29.803]                 }
[01:29:29.803]                 if (length(args) > 0) 
[01:29:29.803]                   base::do.call(base::Sys.setenv, args = args)
[01:29:29.803]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:29.803]             }
[01:29:29.803]             else {
[01:29:29.803]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:29.803]             }
[01:29:29.803]             {
[01:29:29.803]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:29.803]                   0L) {
[01:29:29.803]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:29.803]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:29.803]                   base::options(opts)
[01:29:29.803]                 }
[01:29:29.803]                 {
[01:29:29.803]                   {
[01:29:29.803]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:29.803]                     NULL
[01:29:29.803]                   }
[01:29:29.803]                   options(future.plan = NULL)
[01:29:29.803]                   if (is.na(NA_character_)) 
[01:29:29.803]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:29.803]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:29.803]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:29.803]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:29.803]                     envir = parent.frame()) 
[01:29:29.803]                   {
[01:29:29.803]                     if (is.function(workers)) 
[01:29:29.803]                       workers <- workers()
[01:29:29.803]                     workers <- structure(as.integer(workers), 
[01:29:29.803]                       class = class(workers))
[01:29:29.803]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:29.803]                       workers >= 1)
[01:29:29.803]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:29.803]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:29.803]                     }
[01:29:29.803]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:29.803]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:29.803]                       envir = envir)
[01:29:29.803]                     if (!future$lazy) 
[01:29:29.803]                       future <- run(future)
[01:29:29.803]                     invisible(future)
[01:29:29.803]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:29.803]                 }
[01:29:29.803]             }
[01:29:29.803]         }
[01:29:29.803]     })
[01:29:29.803]     if (TRUE) {
[01:29:29.803]         base::sink(type = "output", split = FALSE)
[01:29:29.803]         if (TRUE) {
[01:29:29.803]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:29.803]         }
[01:29:29.803]         else {
[01:29:29.803]             ...future.result["stdout"] <- base::list(NULL)
[01:29:29.803]         }
[01:29:29.803]         base::close(...future.stdout)
[01:29:29.803]         ...future.stdout <- NULL
[01:29:29.803]     }
[01:29:29.803]     ...future.result$conditions <- ...future.conditions
[01:29:29.803]     ...future.result$finished <- base::Sys.time()
[01:29:29.803]     ...future.result
[01:29:29.803] }
[01:29:29.808] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:29.840] receiveMessageFromWorker() for ClusterFuture ...
[01:29:29.840] - Validating connection of MultisessionFuture
[01:29:29.840] - received message: FutureResult
[01:29:29.841] - Received FutureResult
[01:29:29.841] - Erased future from FutureRegistry
[01:29:29.841] result() for ClusterFuture ...
[01:29:29.841] - result already collected: FutureResult
[01:29:29.841] result() for ClusterFuture ... done
[01:29:29.841] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:29.842] result() for ClusterFuture ...
[01:29:29.842] - result already collected: FutureResult
[01:29:29.842] result() for ClusterFuture ... done
[01:29:29.842] result() for ClusterFuture ...
[01:29:29.842] - result already collected: FutureResult
[01:29:29.842] result() for ClusterFuture ... done
[01:29:29.843] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:29.844] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:29.844] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:29.844] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:29.845] MultisessionFuture started
[01:29:29.845] - Launch lazy future ... done
[01:29:29.845] run() for 'MultisessionFuture' ... done
[01:29:29.845] resolve() on list ...
[01:29:29.846]  recursive: 0
[01:29:29.846]  length: 4
[01:29:29.847] 
[01:29:29.847] Future #1
[01:29:29.847] result() for ClusterFuture ...
[01:29:29.848] - result already collected: FutureResult
[01:29:29.848] result() for ClusterFuture ... done
[01:29:29.848] result() for ClusterFuture ...
[01:29:29.848] - result already collected: FutureResult
[01:29:29.849] result() for ClusterFuture ... done
[01:29:29.849] signalConditionsASAP(MultisessionFuture, pos=1) ...
[01:29:29.849] - nx: 4
[01:29:29.849] - relay: TRUE
[01:29:29.849] - stdout: TRUE
[01:29:29.850] - signal: TRUE
[01:29:29.850] - resignal: FALSE
[01:29:29.850] - force: TRUE
[01:29:29.850] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:29.851] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:29.851]  - until=1
[01:29:29.851]  - relaying element #1
[01:29:29.851] result() for ClusterFuture ...
[01:29:29.852] - result already collected: FutureResult
[01:29:29.852] result() for ClusterFuture ... done
[01:29:29.852] result() for ClusterFuture ...
[01:29:29.852] - result already collected: FutureResult
[01:29:29.853] result() for ClusterFuture ... done
[01:29:29.853] result() for ClusterFuture ...
[01:29:29.853] - result already collected: FutureResult
[01:29:29.854] result() for ClusterFuture ... done
[01:29:29.854] result() for ClusterFuture ...
[01:29:29.854] - result already collected: FutureResult
[01:29:29.854] result() for ClusterFuture ... done
[01:29:29.854] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:29.855] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:29.855] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[01:29:29.855]  length: 3 (resolved future 1)
[01:29:29.855] Future #2
[01:29:29.856] result() for ClusterFuture ...
[01:29:29.856] - result already collected: FutureResult
[01:29:29.856] result() for ClusterFuture ... done
[01:29:29.856] result() for ClusterFuture ...
[01:29:29.857] - result already collected: FutureResult
[01:29:29.857] result() for ClusterFuture ... done
[01:29:29.857] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:29:29.857] - nx: 4
[01:29:29.858] - relay: TRUE
[01:29:29.858] - stdout: TRUE
[01:29:29.858] - signal: TRUE
[01:29:29.858] - resignal: FALSE
[01:29:29.859] - force: TRUE
[01:29:29.859] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:29.859] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:29.859]  - until=2
[01:29:29.860]  - relaying element #2
[01:29:29.860] result() for ClusterFuture ...
[01:29:29.860] - result already collected: FutureResult
[01:29:29.860] result() for ClusterFuture ... done
[01:29:29.861] result() for ClusterFuture ...
[01:29:29.861] - result already collected: FutureResult
[01:29:29.861] result() for ClusterFuture ... done
[01:29:29.861] result() for ClusterFuture ...
[01:29:29.862] - result already collected: FutureResult
[01:29:29.862] result() for ClusterFuture ... done
[01:29:29.862] result() for ClusterFuture ...
[01:29:29.862] - result already collected: FutureResult
[01:29:29.862] result() for ClusterFuture ... done
[01:29:29.863] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:29.863] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:29.863] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:29:29.863]  length: 2 (resolved future 2)
[01:29:29.864] receiveMessageFromWorker() for ClusterFuture ...
[01:29:29.865] - Validating connection of MultisessionFuture
[01:29:29.865] - received message: FutureResult
[01:29:29.865] - Received FutureResult
[01:29:29.866] - Erased future from FutureRegistry
[01:29:29.866] result() for ClusterFuture ...
[01:29:29.866] - result already collected: FutureResult
[01:29:29.866] result() for ClusterFuture ... done
[01:29:29.867] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:29.867] Future #3
[01:29:29.867] result() for ClusterFuture ...
[01:29:29.867] - result already collected: FutureResult
[01:29:29.868] result() for ClusterFuture ... done
[01:29:29.868] result() for ClusterFuture ...
[01:29:29.868] - result already collected: FutureResult
[01:29:29.868] result() for ClusterFuture ... done
[01:29:29.868] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:29:29.869] - nx: 4
[01:29:29.869] - relay: TRUE
[01:29:29.869] - stdout: TRUE
[01:29:29.869] - signal: TRUE
[01:29:29.869] - resignal: FALSE
[01:29:29.870] - force: TRUE
[01:29:29.870] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:29.870] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:29.870]  - until=3
[01:29:29.871]  - relaying element #3
[01:29:29.871] result() for ClusterFuture ...
[01:29:29.871] - result already collected: FutureResult
[01:29:29.871] result() for ClusterFuture ... done
[01:29:29.872] result() for ClusterFuture ...
[01:29:29.872] - result already collected: FutureResult
[01:29:29.872] result() for ClusterFuture ... done
[01:29:29.872] result() for ClusterFuture ...
[01:29:29.873] - result already collected: FutureResult
[01:29:29.873] result() for ClusterFuture ... done
[01:29:29.873] result() for ClusterFuture ...
[01:29:29.873] - result already collected: FutureResult
[01:29:29.874] result() for ClusterFuture ... done
[01:29:29.874] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:29.874] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:29.874] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:29:29.874]  length: 1 (resolved future 3)
[01:29:29.876] receiveMessageFromWorker() for ClusterFuture ...
[01:29:29.877] - Validating connection of MultisessionFuture
[01:29:29.877] - received message: FutureResult
[01:29:29.877] - Received FutureResult
[01:29:29.878] - Erased future from FutureRegistry
[01:29:29.878] result() for ClusterFuture ...
[01:29:29.878] - result already collected: FutureResult
[01:29:29.878] result() for ClusterFuture ... done
[01:29:29.879] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:29.879] Future #4
[01:29:29.879] result() for ClusterFuture ...
[01:29:29.879] - result already collected: FutureResult
[01:29:29.880] result() for ClusterFuture ... done
[01:29:29.880] result() for ClusterFuture ...
[01:29:29.880] - result already collected: FutureResult
[01:29:29.880] result() for ClusterFuture ... done
[01:29:29.880] signalConditionsASAP(MultisessionFuture, pos=4) ...
[01:29:29.881] - nx: 4
[01:29:29.881] - relay: TRUE
[01:29:29.881] - stdout: TRUE
[01:29:29.882] - signal: TRUE
[01:29:29.882] - resignal: FALSE
[01:29:29.882] - force: TRUE
[01:29:29.883] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:29.883] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:29.883]  - until=4
[01:29:29.883]  - relaying element #4
[01:29:29.883] result() for ClusterFuture ...
[01:29:29.884] - result already collected: FutureResult
[01:29:29.884] result() for ClusterFuture ... done
[01:29:29.884] result() for ClusterFuture ...
[01:29:29.884] - result already collected: FutureResult
[01:29:29.884] result() for ClusterFuture ... done
[01:29:29.885] result() for ClusterFuture ...
[01:29:29.885] - result already collected: FutureResult
[01:29:29.885] result() for ClusterFuture ... done
[01:29:29.886] result() for ClusterFuture ...
[01:29:29.886] - result already collected: FutureResult
[01:29:29.886] result() for ClusterFuture ... done
[01:29:29.886] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:29.886] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:29.887] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[01:29:29.887]  length: 0 (resolved future 4)
[01:29:29.887] Relaying remaining futures
[01:29:29.887] signalConditionsASAP(NULL, pos=0) ...
[01:29:29.888] - nx: 4
[01:29:29.888] - relay: TRUE
[01:29:29.888] - stdout: TRUE
[01:29:29.888] - signal: TRUE
[01:29:29.888] - resignal: FALSE
[01:29:29.889] - force: TRUE
[01:29:29.889] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:29.889] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[01:29:29.889] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:29.890] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:29.890] signalConditionsASAP(NULL, pos=0) ... done
[01:29:29.890] resolve() on list ... DONE
[01:29:29.890] result() for ClusterFuture ...
[01:29:29.891] - result already collected: FutureResult
[01:29:29.891] result() for ClusterFuture ... done
[01:29:29.891] result() for ClusterFuture ...
[01:29:29.891] - result already collected: FutureResult
[01:29:29.891] result() for ClusterFuture ... done
[01:29:29.892] result() for ClusterFuture ...
[01:29:29.892] - result already collected: FutureResult
[01:29:29.892] result() for ClusterFuture ... done
[01:29:29.892] result() for ClusterFuture ...
[01:29:29.893] - result already collected: FutureResult
[01:29:29.893] result() for ClusterFuture ... done
[01:29:29.893] result() for ClusterFuture ...
[01:29:29.893] - result already collected: FutureResult
[01:29:29.894] result() for ClusterFuture ... done
[01:29:29.894] result() for ClusterFuture ...
[01:29:29.894] - result already collected: FutureResult
[01:29:29.894] result() for ClusterFuture ... done
[01:29:29.895] result() for ClusterFuture ...
[01:29:29.895] - result already collected: FutureResult
[01:29:29.895] result() for ClusterFuture ... done
[01:29:29.895] result() for ClusterFuture ...
[01:29:29.895] - result already collected: FutureResult
[01:29:29.896] result() for ClusterFuture ... done
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[01:29:29.896] getGlobalsAndPackages() ...
[01:29:29.897] Searching for globals...
[01:29:29.899] - globals found: [3] '{', 'sample', 'x'
[01:29:29.899] Searching for globals ... DONE
[01:29:29.900] Resolving globals: FALSE
[01:29:29.900] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:29.901] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:29.901] - globals: [1] 'x'
[01:29:29.902] 
[01:29:29.902] getGlobalsAndPackages() ... DONE
[01:29:29.902] run() for 'Future' ...
[01:29:29.903] - state: 'created'
[01:29:29.903] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:29.920] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:29.920] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:29.920]   - Field: 'node'
[01:29:29.921]   - Field: 'label'
[01:29:29.921]   - Field: 'local'
[01:29:29.921]   - Field: 'owner'
[01:29:29.922]   - Field: 'envir'
[01:29:29.922]   - Field: 'workers'
[01:29:29.922]   - Field: 'packages'
[01:29:29.922]   - Field: 'gc'
[01:29:29.923]   - Field: 'conditions'
[01:29:29.923]   - Field: 'persistent'
[01:29:29.923]   - Field: 'expr'
[01:29:29.923]   - Field: 'uuid'
[01:29:29.924]   - Field: 'seed'
[01:29:29.924]   - Field: 'version'
[01:29:29.924]   - Field: 'result'
[01:29:29.925]   - Field: 'asynchronous'
[01:29:29.925]   - Field: 'calls'
[01:29:29.925]   - Field: 'globals'
[01:29:29.925]   - Field: 'stdout'
[01:29:29.925]   - Field: 'earlySignal'
[01:29:29.926]   - Field: 'lazy'
[01:29:29.926]   - Field: 'state'
[01:29:29.926] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:29.926] - Launch lazy future ...
[01:29:29.927] Packages needed by the future expression (n = 0): <none>
[01:29:29.927] Packages needed by future strategies (n = 0): <none>
[01:29:29.928] {
[01:29:29.928]     {
[01:29:29.928]         {
[01:29:29.928]             ...future.startTime <- base::Sys.time()
[01:29:29.928]             {
[01:29:29.928]                 {
[01:29:29.928]                   {
[01:29:29.928]                     {
[01:29:29.928]                       {
[01:29:29.928]                         base::local({
[01:29:29.928]                           has_future <- base::requireNamespace("future", 
[01:29:29.928]                             quietly = TRUE)
[01:29:29.928]                           if (has_future) {
[01:29:29.928]                             ns <- base::getNamespace("future")
[01:29:29.928]                             version <- ns[[".package"]][["version"]]
[01:29:29.928]                             if (is.null(version)) 
[01:29:29.928]                               version <- utils::packageVersion("future")
[01:29:29.928]                           }
[01:29:29.928]                           else {
[01:29:29.928]                             version <- NULL
[01:29:29.928]                           }
[01:29:29.928]                           if (!has_future || version < "1.8.0") {
[01:29:29.928]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:29.928]                               "", base::R.version$version.string), 
[01:29:29.928]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:29.928]                                 base::R.version$platform, 8 * 
[01:29:29.928]                                   base::.Machine$sizeof.pointer), 
[01:29:29.928]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:29.928]                                 "release", "version")], collapse = " "), 
[01:29:29.928]                               hostname = base::Sys.info()[["nodename"]])
[01:29:29.928]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:29.928]                               info)
[01:29:29.928]                             info <- base::paste(info, collapse = "; ")
[01:29:29.928]                             if (!has_future) {
[01:29:29.928]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:29.928]                                 info)
[01:29:29.928]                             }
[01:29:29.928]                             else {
[01:29:29.928]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:29.928]                                 info, version)
[01:29:29.928]                             }
[01:29:29.928]                             base::stop(msg)
[01:29:29.928]                           }
[01:29:29.928]                         })
[01:29:29.928]                       }
[01:29:29.928]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:29.928]                       base::options(mc.cores = 1L)
[01:29:29.928]                     }
[01:29:29.928]                     options(future.plan = NULL)
[01:29:29.928]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:29.928]                     future::plan("default", .cleanup = FALSE, 
[01:29:29.928]                       .init = FALSE)
[01:29:29.928]                   }
[01:29:29.928]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[01:29:29.928]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[01:29:29.928]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[01:29:29.928]                 }
[01:29:29.928]                 ...future.workdir <- getwd()
[01:29:29.928]             }
[01:29:29.928]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:29.928]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:29.928]         }
[01:29:29.928]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:29.928]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:29.928]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:29.928]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:29.928]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:29.928]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:29.928]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:29.928]             base::names(...future.oldOptions))
[01:29:29.928]     }
[01:29:29.928]     if (FALSE) {
[01:29:29.928]     }
[01:29:29.928]     else {
[01:29:29.928]         if (TRUE) {
[01:29:29.928]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:29.928]                 open = "w")
[01:29:29.928]         }
[01:29:29.928]         else {
[01:29:29.928]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:29.928]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:29.928]         }
[01:29:29.928]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:29.928]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:29.928]             base::sink(type = "output", split = FALSE)
[01:29:29.928]             base::close(...future.stdout)
[01:29:29.928]         }, add = TRUE)
[01:29:29.928]     }
[01:29:29.928]     ...future.frame <- base::sys.nframe()
[01:29:29.928]     ...future.conditions <- base::list()
[01:29:29.928]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:29.928]     if (FALSE) {
[01:29:29.928]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:29.928]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:29.928]     }
[01:29:29.928]     ...future.result <- base::tryCatch({
[01:29:29.928]         base::withCallingHandlers({
[01:29:29.928]             ...future.value <- base::withVisible(base::local({
[01:29:29.928]                 ...future.makeSendCondition <- base::local({
[01:29:29.928]                   sendCondition <- NULL
[01:29:29.928]                   function(frame = 1L) {
[01:29:29.928]                     if (is.function(sendCondition)) 
[01:29:29.928]                       return(sendCondition)
[01:29:29.928]                     ns <- getNamespace("parallel")
[01:29:29.928]                     if (exists("sendData", mode = "function", 
[01:29:29.928]                       envir = ns)) {
[01:29:29.928]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:29.928]                         envir = ns)
[01:29:29.928]                       envir <- sys.frame(frame)
[01:29:29.928]                       master <- NULL
[01:29:29.928]                       while (!identical(envir, .GlobalEnv) && 
[01:29:29.928]                         !identical(envir, emptyenv())) {
[01:29:29.928]                         if (exists("master", mode = "list", envir = envir, 
[01:29:29.928]                           inherits = FALSE)) {
[01:29:29.928]                           master <- get("master", mode = "list", 
[01:29:29.928]                             envir = envir, inherits = FALSE)
[01:29:29.928]                           if (inherits(master, c("SOCKnode", 
[01:29:29.928]                             "SOCK0node"))) {
[01:29:29.928]                             sendCondition <<- function(cond) {
[01:29:29.928]                               data <- list(type = "VALUE", value = cond, 
[01:29:29.928]                                 success = TRUE)
[01:29:29.928]                               parallel_sendData(master, data)
[01:29:29.928]                             }
[01:29:29.928]                             return(sendCondition)
[01:29:29.928]                           }
[01:29:29.928]                         }
[01:29:29.928]                         frame <- frame + 1L
[01:29:29.928]                         envir <- sys.frame(frame)
[01:29:29.928]                       }
[01:29:29.928]                     }
[01:29:29.928]                     sendCondition <<- function(cond) NULL
[01:29:29.928]                   }
[01:29:29.928]                 })
[01:29:29.928]                 withCallingHandlers({
[01:29:29.928]                   {
[01:29:29.928]                     sample(x, size = 1L)
[01:29:29.928]                   }
[01:29:29.928]                 }, immediateCondition = function(cond) {
[01:29:29.928]                   sendCondition <- ...future.makeSendCondition()
[01:29:29.928]                   sendCondition(cond)
[01:29:29.928]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.928]                   {
[01:29:29.928]                     inherits <- base::inherits
[01:29:29.928]                     invokeRestart <- base::invokeRestart
[01:29:29.928]                     is.null <- base::is.null
[01:29:29.928]                     muffled <- FALSE
[01:29:29.928]                     if (inherits(cond, "message")) {
[01:29:29.928]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:29.928]                       if (muffled) 
[01:29:29.928]                         invokeRestart("muffleMessage")
[01:29:29.928]                     }
[01:29:29.928]                     else if (inherits(cond, "warning")) {
[01:29:29.928]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:29.928]                       if (muffled) 
[01:29:29.928]                         invokeRestart("muffleWarning")
[01:29:29.928]                     }
[01:29:29.928]                     else if (inherits(cond, "condition")) {
[01:29:29.928]                       if (!is.null(pattern)) {
[01:29:29.928]                         computeRestarts <- base::computeRestarts
[01:29:29.928]                         grepl <- base::grepl
[01:29:29.928]                         restarts <- computeRestarts(cond)
[01:29:29.928]                         for (restart in restarts) {
[01:29:29.928]                           name <- restart$name
[01:29:29.928]                           if (is.null(name)) 
[01:29:29.928]                             next
[01:29:29.928]                           if (!grepl(pattern, name)) 
[01:29:29.928]                             next
[01:29:29.928]                           invokeRestart(restart)
[01:29:29.928]                           muffled <- TRUE
[01:29:29.928]                           break
[01:29:29.928]                         }
[01:29:29.928]                       }
[01:29:29.928]                     }
[01:29:29.928]                     invisible(muffled)
[01:29:29.928]                   }
[01:29:29.928]                   muffleCondition(cond)
[01:29:29.928]                 })
[01:29:29.928]             }))
[01:29:29.928]             future::FutureResult(value = ...future.value$value, 
[01:29:29.928]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:29.928]                   ...future.rng), globalenv = if (FALSE) 
[01:29:29.928]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:29.928]                     ...future.globalenv.names))
[01:29:29.928]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:29.928]         }, condition = base::local({
[01:29:29.928]             c <- base::c
[01:29:29.928]             inherits <- base::inherits
[01:29:29.928]             invokeRestart <- base::invokeRestart
[01:29:29.928]             length <- base::length
[01:29:29.928]             list <- base::list
[01:29:29.928]             seq.int <- base::seq.int
[01:29:29.928]             signalCondition <- base::signalCondition
[01:29:29.928]             sys.calls <- base::sys.calls
[01:29:29.928]             `[[` <- base::`[[`
[01:29:29.928]             `+` <- base::`+`
[01:29:29.928]             `<<-` <- base::`<<-`
[01:29:29.928]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:29.928]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:29.928]                   3L)]
[01:29:29.928]             }
[01:29:29.928]             function(cond) {
[01:29:29.928]                 is_error <- inherits(cond, "error")
[01:29:29.928]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:29.928]                   NULL)
[01:29:29.928]                 if (is_error) {
[01:29:29.928]                   sessionInformation <- function() {
[01:29:29.928]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:29.928]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:29.928]                       search = base::search(), system = base::Sys.info())
[01:29:29.928]                   }
[01:29:29.928]                   ...future.conditions[[length(...future.conditions) + 
[01:29:29.928]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:29.928]                     cond$call), session = sessionInformation(), 
[01:29:29.928]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:29.928]                   signalCondition(cond)
[01:29:29.928]                 }
[01:29:29.928]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:29.928]                 "immediateCondition"))) {
[01:29:29.928]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:29.928]                   ...future.conditions[[length(...future.conditions) + 
[01:29:29.928]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:29.928]                   if (TRUE && !signal) {
[01:29:29.928]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.928]                     {
[01:29:29.928]                       inherits <- base::inherits
[01:29:29.928]                       invokeRestart <- base::invokeRestart
[01:29:29.928]                       is.null <- base::is.null
[01:29:29.928]                       muffled <- FALSE
[01:29:29.928]                       if (inherits(cond, "message")) {
[01:29:29.928]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:29.928]                         if (muffled) 
[01:29:29.928]                           invokeRestart("muffleMessage")
[01:29:29.928]                       }
[01:29:29.928]                       else if (inherits(cond, "warning")) {
[01:29:29.928]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:29.928]                         if (muffled) 
[01:29:29.928]                           invokeRestart("muffleWarning")
[01:29:29.928]                       }
[01:29:29.928]                       else if (inherits(cond, "condition")) {
[01:29:29.928]                         if (!is.null(pattern)) {
[01:29:29.928]                           computeRestarts <- base::computeRestarts
[01:29:29.928]                           grepl <- base::grepl
[01:29:29.928]                           restarts <- computeRestarts(cond)
[01:29:29.928]                           for (restart in restarts) {
[01:29:29.928]                             name <- restart$name
[01:29:29.928]                             if (is.null(name)) 
[01:29:29.928]                               next
[01:29:29.928]                             if (!grepl(pattern, name)) 
[01:29:29.928]                               next
[01:29:29.928]                             invokeRestart(restart)
[01:29:29.928]                             muffled <- TRUE
[01:29:29.928]                             break
[01:29:29.928]                           }
[01:29:29.928]                         }
[01:29:29.928]                       }
[01:29:29.928]                       invisible(muffled)
[01:29:29.928]                     }
[01:29:29.928]                     muffleCondition(cond, pattern = "^muffle")
[01:29:29.928]                   }
[01:29:29.928]                 }
[01:29:29.928]                 else {
[01:29:29.928]                   if (TRUE) {
[01:29:29.928]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.928]                     {
[01:29:29.928]                       inherits <- base::inherits
[01:29:29.928]                       invokeRestart <- base::invokeRestart
[01:29:29.928]                       is.null <- base::is.null
[01:29:29.928]                       muffled <- FALSE
[01:29:29.928]                       if (inherits(cond, "message")) {
[01:29:29.928]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:29.928]                         if (muffled) 
[01:29:29.928]                           invokeRestart("muffleMessage")
[01:29:29.928]                       }
[01:29:29.928]                       else if (inherits(cond, "warning")) {
[01:29:29.928]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:29.928]                         if (muffled) 
[01:29:29.928]                           invokeRestart("muffleWarning")
[01:29:29.928]                       }
[01:29:29.928]                       else if (inherits(cond, "condition")) {
[01:29:29.928]                         if (!is.null(pattern)) {
[01:29:29.928]                           computeRestarts <- base::computeRestarts
[01:29:29.928]                           grepl <- base::grepl
[01:29:29.928]                           restarts <- computeRestarts(cond)
[01:29:29.928]                           for (restart in restarts) {
[01:29:29.928]                             name <- restart$name
[01:29:29.928]                             if (is.null(name)) 
[01:29:29.928]                               next
[01:29:29.928]                             if (!grepl(pattern, name)) 
[01:29:29.928]                               next
[01:29:29.928]                             invokeRestart(restart)
[01:29:29.928]                             muffled <- TRUE
[01:29:29.928]                             break
[01:29:29.928]                           }
[01:29:29.928]                         }
[01:29:29.928]                       }
[01:29:29.928]                       invisible(muffled)
[01:29:29.928]                     }
[01:29:29.928]                     muffleCondition(cond, pattern = "^muffle")
[01:29:29.928]                   }
[01:29:29.928]                 }
[01:29:29.928]             }
[01:29:29.928]         }))
[01:29:29.928]     }, error = function(ex) {
[01:29:29.928]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:29.928]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:29.928]                 ...future.rng), started = ...future.startTime, 
[01:29:29.928]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:29.928]             version = "1.8"), class = "FutureResult")
[01:29:29.928]     }, finally = {
[01:29:29.928]         if (!identical(...future.workdir, getwd())) 
[01:29:29.928]             setwd(...future.workdir)
[01:29:29.928]         {
[01:29:29.928]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:29.928]                 ...future.oldOptions$nwarnings <- NULL
[01:29:29.928]             }
[01:29:29.928]             base::options(...future.oldOptions)
[01:29:29.928]             if (.Platform$OS.type == "windows") {
[01:29:29.928]                 old_names <- names(...future.oldEnvVars)
[01:29:29.928]                 envs <- base::Sys.getenv()
[01:29:29.928]                 names <- names(envs)
[01:29:29.928]                 common <- intersect(names, old_names)
[01:29:29.928]                 added <- setdiff(names, old_names)
[01:29:29.928]                 removed <- setdiff(old_names, names)
[01:29:29.928]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:29.928]                   envs[common]]
[01:29:29.928]                 NAMES <- toupper(changed)
[01:29:29.928]                 args <- list()
[01:29:29.928]                 for (kk in seq_along(NAMES)) {
[01:29:29.928]                   name <- changed[[kk]]
[01:29:29.928]                   NAME <- NAMES[[kk]]
[01:29:29.928]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.928]                     next
[01:29:29.928]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:29.928]                 }
[01:29:29.928]                 NAMES <- toupper(added)
[01:29:29.928]                 for (kk in seq_along(NAMES)) {
[01:29:29.928]                   name <- added[[kk]]
[01:29:29.928]                   NAME <- NAMES[[kk]]
[01:29:29.928]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.928]                     next
[01:29:29.928]                   args[[name]] <- ""
[01:29:29.928]                 }
[01:29:29.928]                 NAMES <- toupper(removed)
[01:29:29.928]                 for (kk in seq_along(NAMES)) {
[01:29:29.928]                   name <- removed[[kk]]
[01:29:29.928]                   NAME <- NAMES[[kk]]
[01:29:29.928]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.928]                     next
[01:29:29.928]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:29.928]                 }
[01:29:29.928]                 if (length(args) > 0) 
[01:29:29.928]                   base::do.call(base::Sys.setenv, args = args)
[01:29:29.928]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:29.928]             }
[01:29:29.928]             else {
[01:29:29.928]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:29.928]             }
[01:29:29.928]             {
[01:29:29.928]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:29.928]                   0L) {
[01:29:29.928]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:29.928]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:29.928]                   base::options(opts)
[01:29:29.928]                 }
[01:29:29.928]                 {
[01:29:29.928]                   {
[01:29:29.928]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:29.928]                     NULL
[01:29:29.928]                   }
[01:29:29.928]                   options(future.plan = NULL)
[01:29:29.928]                   if (is.na(NA_character_)) 
[01:29:29.928]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:29.928]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:29.928]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:29.928]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:29.928]                     envir = parent.frame()) 
[01:29:29.928]                   {
[01:29:29.928]                     if (is.function(workers)) 
[01:29:29.928]                       workers <- workers()
[01:29:29.928]                     workers <- structure(as.integer(workers), 
[01:29:29.928]                       class = class(workers))
[01:29:29.928]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:29.928]                       workers >= 1)
[01:29:29.928]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:29.928]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:29.928]                     }
[01:29:29.928]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:29.928]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:29.928]                       envir = envir)
[01:29:29.928]                     if (!future$lazy) 
[01:29:29.928]                       future <- run(future)
[01:29:29.928]                     invisible(future)
[01:29:29.928]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:29.928]                 }
[01:29:29.928]             }
[01:29:29.928]         }
[01:29:29.928]     })
[01:29:29.928]     if (TRUE) {
[01:29:29.928]         base::sink(type = "output", split = FALSE)
[01:29:29.928]         if (TRUE) {
[01:29:29.928]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:29.928]         }
[01:29:29.928]         else {
[01:29:29.928]             ...future.result["stdout"] <- base::list(NULL)
[01:29:29.928]         }
[01:29:29.928]         base::close(...future.stdout)
[01:29:29.928]         ...future.stdout <- NULL
[01:29:29.928]     }
[01:29:29.928]     ...future.result$conditions <- ...future.conditions
[01:29:29.928]     ...future.result$finished <- base::Sys.time()
[01:29:29.928]     ...future.result
[01:29:29.928] }
[01:29:29.935] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:29.935] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:29.936] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:29.936] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:29.937] MultisessionFuture started
[01:29:29.937] - Launch lazy future ... done
[01:29:29.937] run() for 'MultisessionFuture' ... done
[01:29:29.938] getGlobalsAndPackages() ...
[01:29:29.938] Searching for globals...
[01:29:29.939] - globals found: [3] '{', 'sample', 'x'
[01:29:29.940] Searching for globals ... DONE
[01:29:29.940] Resolving globals: FALSE
[01:29:29.940] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:29.941] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:29.941] - globals: [1] 'x'
[01:29:29.941] 
[01:29:29.942] getGlobalsAndPackages() ... DONE
[01:29:29.942] run() for 'Future' ...
[01:29:29.942] - state: 'created'
[01:29:29.942] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:29.958] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:29.959] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:29.959]   - Field: 'node'
[01:29:29.959]   - Field: 'label'
[01:29:29.959]   - Field: 'local'
[01:29:29.959]   - Field: 'owner'
[01:29:29.960]   - Field: 'envir'
[01:29:29.960]   - Field: 'workers'
[01:29:29.960]   - Field: 'packages'
[01:29:29.960]   - Field: 'gc'
[01:29:29.960]   - Field: 'conditions'
[01:29:29.960]   - Field: 'persistent'
[01:29:29.961]   - Field: 'expr'
[01:29:29.961]   - Field: 'uuid'
[01:29:29.961]   - Field: 'seed'
[01:29:29.961]   - Field: 'version'
[01:29:29.961]   - Field: 'result'
[01:29:29.962]   - Field: 'asynchronous'
[01:29:29.962]   - Field: 'calls'
[01:29:29.962]   - Field: 'globals'
[01:29:29.962]   - Field: 'stdout'
[01:29:29.962]   - Field: 'earlySignal'
[01:29:29.962]   - Field: 'lazy'
[01:29:29.963]   - Field: 'state'
[01:29:29.963] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:29.963] - Launch lazy future ...
[01:29:29.963] Packages needed by the future expression (n = 0): <none>
[01:29:29.964] Packages needed by future strategies (n = 0): <none>
[01:29:29.964] {
[01:29:29.964]     {
[01:29:29.964]         {
[01:29:29.964]             ...future.startTime <- base::Sys.time()
[01:29:29.964]             {
[01:29:29.964]                 {
[01:29:29.964]                   {
[01:29:29.964]                     {
[01:29:29.964]                       {
[01:29:29.964]                         base::local({
[01:29:29.964]                           has_future <- base::requireNamespace("future", 
[01:29:29.964]                             quietly = TRUE)
[01:29:29.964]                           if (has_future) {
[01:29:29.964]                             ns <- base::getNamespace("future")
[01:29:29.964]                             version <- ns[[".package"]][["version"]]
[01:29:29.964]                             if (is.null(version)) 
[01:29:29.964]                               version <- utils::packageVersion("future")
[01:29:29.964]                           }
[01:29:29.964]                           else {
[01:29:29.964]                             version <- NULL
[01:29:29.964]                           }
[01:29:29.964]                           if (!has_future || version < "1.8.0") {
[01:29:29.964]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:29.964]                               "", base::R.version$version.string), 
[01:29:29.964]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:29.964]                                 base::R.version$platform, 8 * 
[01:29:29.964]                                   base::.Machine$sizeof.pointer), 
[01:29:29.964]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:29.964]                                 "release", "version")], collapse = " "), 
[01:29:29.964]                               hostname = base::Sys.info()[["nodename"]])
[01:29:29.964]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:29.964]                               info)
[01:29:29.964]                             info <- base::paste(info, collapse = "; ")
[01:29:29.964]                             if (!has_future) {
[01:29:29.964]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:29.964]                                 info)
[01:29:29.964]                             }
[01:29:29.964]                             else {
[01:29:29.964]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:29.964]                                 info, version)
[01:29:29.964]                             }
[01:29:29.964]                             base::stop(msg)
[01:29:29.964]                           }
[01:29:29.964]                         })
[01:29:29.964]                       }
[01:29:29.964]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:29.964]                       base::options(mc.cores = 1L)
[01:29:29.964]                     }
[01:29:29.964]                     options(future.plan = NULL)
[01:29:29.964]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:29.964]                     future::plan("default", .cleanup = FALSE, 
[01:29:29.964]                       .init = FALSE)
[01:29:29.964]                   }
[01:29:29.964]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[01:29:29.964]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[01:29:29.964]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[01:29:29.964]                 }
[01:29:29.964]                 ...future.workdir <- getwd()
[01:29:29.964]             }
[01:29:29.964]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:29.964]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:29.964]         }
[01:29:29.964]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:29.964]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:29.964]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:29.964]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:29.964]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:29.964]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:29.964]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:29.964]             base::names(...future.oldOptions))
[01:29:29.964]     }
[01:29:29.964]     if (FALSE) {
[01:29:29.964]     }
[01:29:29.964]     else {
[01:29:29.964]         if (TRUE) {
[01:29:29.964]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:29.964]                 open = "w")
[01:29:29.964]         }
[01:29:29.964]         else {
[01:29:29.964]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:29.964]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:29.964]         }
[01:29:29.964]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:29.964]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:29.964]             base::sink(type = "output", split = FALSE)
[01:29:29.964]             base::close(...future.stdout)
[01:29:29.964]         }, add = TRUE)
[01:29:29.964]     }
[01:29:29.964]     ...future.frame <- base::sys.nframe()
[01:29:29.964]     ...future.conditions <- base::list()
[01:29:29.964]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:29.964]     if (FALSE) {
[01:29:29.964]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:29.964]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:29.964]     }
[01:29:29.964]     ...future.result <- base::tryCatch({
[01:29:29.964]         base::withCallingHandlers({
[01:29:29.964]             ...future.value <- base::withVisible(base::local({
[01:29:29.964]                 ...future.makeSendCondition <- base::local({
[01:29:29.964]                   sendCondition <- NULL
[01:29:29.964]                   function(frame = 1L) {
[01:29:29.964]                     if (is.function(sendCondition)) 
[01:29:29.964]                       return(sendCondition)
[01:29:29.964]                     ns <- getNamespace("parallel")
[01:29:29.964]                     if (exists("sendData", mode = "function", 
[01:29:29.964]                       envir = ns)) {
[01:29:29.964]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:29.964]                         envir = ns)
[01:29:29.964]                       envir <- sys.frame(frame)
[01:29:29.964]                       master <- NULL
[01:29:29.964]                       while (!identical(envir, .GlobalEnv) && 
[01:29:29.964]                         !identical(envir, emptyenv())) {
[01:29:29.964]                         if (exists("master", mode = "list", envir = envir, 
[01:29:29.964]                           inherits = FALSE)) {
[01:29:29.964]                           master <- get("master", mode = "list", 
[01:29:29.964]                             envir = envir, inherits = FALSE)
[01:29:29.964]                           if (inherits(master, c("SOCKnode", 
[01:29:29.964]                             "SOCK0node"))) {
[01:29:29.964]                             sendCondition <<- function(cond) {
[01:29:29.964]                               data <- list(type = "VALUE", value = cond, 
[01:29:29.964]                                 success = TRUE)
[01:29:29.964]                               parallel_sendData(master, data)
[01:29:29.964]                             }
[01:29:29.964]                             return(sendCondition)
[01:29:29.964]                           }
[01:29:29.964]                         }
[01:29:29.964]                         frame <- frame + 1L
[01:29:29.964]                         envir <- sys.frame(frame)
[01:29:29.964]                       }
[01:29:29.964]                     }
[01:29:29.964]                     sendCondition <<- function(cond) NULL
[01:29:29.964]                   }
[01:29:29.964]                 })
[01:29:29.964]                 withCallingHandlers({
[01:29:29.964]                   {
[01:29:29.964]                     sample(x, size = 1L)
[01:29:29.964]                   }
[01:29:29.964]                 }, immediateCondition = function(cond) {
[01:29:29.964]                   sendCondition <- ...future.makeSendCondition()
[01:29:29.964]                   sendCondition(cond)
[01:29:29.964]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.964]                   {
[01:29:29.964]                     inherits <- base::inherits
[01:29:29.964]                     invokeRestart <- base::invokeRestart
[01:29:29.964]                     is.null <- base::is.null
[01:29:29.964]                     muffled <- FALSE
[01:29:29.964]                     if (inherits(cond, "message")) {
[01:29:29.964]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:29.964]                       if (muffled) 
[01:29:29.964]                         invokeRestart("muffleMessage")
[01:29:29.964]                     }
[01:29:29.964]                     else if (inherits(cond, "warning")) {
[01:29:29.964]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:29.964]                       if (muffled) 
[01:29:29.964]                         invokeRestart("muffleWarning")
[01:29:29.964]                     }
[01:29:29.964]                     else if (inherits(cond, "condition")) {
[01:29:29.964]                       if (!is.null(pattern)) {
[01:29:29.964]                         computeRestarts <- base::computeRestarts
[01:29:29.964]                         grepl <- base::grepl
[01:29:29.964]                         restarts <- computeRestarts(cond)
[01:29:29.964]                         for (restart in restarts) {
[01:29:29.964]                           name <- restart$name
[01:29:29.964]                           if (is.null(name)) 
[01:29:29.964]                             next
[01:29:29.964]                           if (!grepl(pattern, name)) 
[01:29:29.964]                             next
[01:29:29.964]                           invokeRestart(restart)
[01:29:29.964]                           muffled <- TRUE
[01:29:29.964]                           break
[01:29:29.964]                         }
[01:29:29.964]                       }
[01:29:29.964]                     }
[01:29:29.964]                     invisible(muffled)
[01:29:29.964]                   }
[01:29:29.964]                   muffleCondition(cond)
[01:29:29.964]                 })
[01:29:29.964]             }))
[01:29:29.964]             future::FutureResult(value = ...future.value$value, 
[01:29:29.964]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:29.964]                   ...future.rng), globalenv = if (FALSE) 
[01:29:29.964]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:29.964]                     ...future.globalenv.names))
[01:29:29.964]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:29.964]         }, condition = base::local({
[01:29:29.964]             c <- base::c
[01:29:29.964]             inherits <- base::inherits
[01:29:29.964]             invokeRestart <- base::invokeRestart
[01:29:29.964]             length <- base::length
[01:29:29.964]             list <- base::list
[01:29:29.964]             seq.int <- base::seq.int
[01:29:29.964]             signalCondition <- base::signalCondition
[01:29:29.964]             sys.calls <- base::sys.calls
[01:29:29.964]             `[[` <- base::`[[`
[01:29:29.964]             `+` <- base::`+`
[01:29:29.964]             `<<-` <- base::`<<-`
[01:29:29.964]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:29.964]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:29.964]                   3L)]
[01:29:29.964]             }
[01:29:29.964]             function(cond) {
[01:29:29.964]                 is_error <- inherits(cond, "error")
[01:29:29.964]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:29.964]                   NULL)
[01:29:29.964]                 if (is_error) {
[01:29:29.964]                   sessionInformation <- function() {
[01:29:29.964]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:29.964]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:29.964]                       search = base::search(), system = base::Sys.info())
[01:29:29.964]                   }
[01:29:29.964]                   ...future.conditions[[length(...future.conditions) + 
[01:29:29.964]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:29.964]                     cond$call), session = sessionInformation(), 
[01:29:29.964]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:29.964]                   signalCondition(cond)
[01:29:29.964]                 }
[01:29:29.964]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:29.964]                 "immediateCondition"))) {
[01:29:29.964]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:29.964]                   ...future.conditions[[length(...future.conditions) + 
[01:29:29.964]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:29.964]                   if (TRUE && !signal) {
[01:29:29.964]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.964]                     {
[01:29:29.964]                       inherits <- base::inherits
[01:29:29.964]                       invokeRestart <- base::invokeRestart
[01:29:29.964]                       is.null <- base::is.null
[01:29:29.964]                       muffled <- FALSE
[01:29:29.964]                       if (inherits(cond, "message")) {
[01:29:29.964]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:29.964]                         if (muffled) 
[01:29:29.964]                           invokeRestart("muffleMessage")
[01:29:29.964]                       }
[01:29:29.964]                       else if (inherits(cond, "warning")) {
[01:29:29.964]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:29.964]                         if (muffled) 
[01:29:29.964]                           invokeRestart("muffleWarning")
[01:29:29.964]                       }
[01:29:29.964]                       else if (inherits(cond, "condition")) {
[01:29:29.964]                         if (!is.null(pattern)) {
[01:29:29.964]                           computeRestarts <- base::computeRestarts
[01:29:29.964]                           grepl <- base::grepl
[01:29:29.964]                           restarts <- computeRestarts(cond)
[01:29:29.964]                           for (restart in restarts) {
[01:29:29.964]                             name <- restart$name
[01:29:29.964]                             if (is.null(name)) 
[01:29:29.964]                               next
[01:29:29.964]                             if (!grepl(pattern, name)) 
[01:29:29.964]                               next
[01:29:29.964]                             invokeRestart(restart)
[01:29:29.964]                             muffled <- TRUE
[01:29:29.964]                             break
[01:29:29.964]                           }
[01:29:29.964]                         }
[01:29:29.964]                       }
[01:29:29.964]                       invisible(muffled)
[01:29:29.964]                     }
[01:29:29.964]                     muffleCondition(cond, pattern = "^muffle")
[01:29:29.964]                   }
[01:29:29.964]                 }
[01:29:29.964]                 else {
[01:29:29.964]                   if (TRUE) {
[01:29:29.964]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.964]                     {
[01:29:29.964]                       inherits <- base::inherits
[01:29:29.964]                       invokeRestart <- base::invokeRestart
[01:29:29.964]                       is.null <- base::is.null
[01:29:29.964]                       muffled <- FALSE
[01:29:29.964]                       if (inherits(cond, "message")) {
[01:29:29.964]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:29.964]                         if (muffled) 
[01:29:29.964]                           invokeRestart("muffleMessage")
[01:29:29.964]                       }
[01:29:29.964]                       else if (inherits(cond, "warning")) {
[01:29:29.964]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:29.964]                         if (muffled) 
[01:29:29.964]                           invokeRestart("muffleWarning")
[01:29:29.964]                       }
[01:29:29.964]                       else if (inherits(cond, "condition")) {
[01:29:29.964]                         if (!is.null(pattern)) {
[01:29:29.964]                           computeRestarts <- base::computeRestarts
[01:29:29.964]                           grepl <- base::grepl
[01:29:29.964]                           restarts <- computeRestarts(cond)
[01:29:29.964]                           for (restart in restarts) {
[01:29:29.964]                             name <- restart$name
[01:29:29.964]                             if (is.null(name)) 
[01:29:29.964]                               next
[01:29:29.964]                             if (!grepl(pattern, name)) 
[01:29:29.964]                               next
[01:29:29.964]                             invokeRestart(restart)
[01:29:29.964]                             muffled <- TRUE
[01:29:29.964]                             break
[01:29:29.964]                           }
[01:29:29.964]                         }
[01:29:29.964]                       }
[01:29:29.964]                       invisible(muffled)
[01:29:29.964]                     }
[01:29:29.964]                     muffleCondition(cond, pattern = "^muffle")
[01:29:29.964]                   }
[01:29:29.964]                 }
[01:29:29.964]             }
[01:29:29.964]         }))
[01:29:29.964]     }, error = function(ex) {
[01:29:29.964]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:29.964]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:29.964]                 ...future.rng), started = ...future.startTime, 
[01:29:29.964]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:29.964]             version = "1.8"), class = "FutureResult")
[01:29:29.964]     }, finally = {
[01:29:29.964]         if (!identical(...future.workdir, getwd())) 
[01:29:29.964]             setwd(...future.workdir)
[01:29:29.964]         {
[01:29:29.964]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:29.964]                 ...future.oldOptions$nwarnings <- NULL
[01:29:29.964]             }
[01:29:29.964]             base::options(...future.oldOptions)
[01:29:29.964]             if (.Platform$OS.type == "windows") {
[01:29:29.964]                 old_names <- names(...future.oldEnvVars)
[01:29:29.964]                 envs <- base::Sys.getenv()
[01:29:29.964]                 names <- names(envs)
[01:29:29.964]                 common <- intersect(names, old_names)
[01:29:29.964]                 added <- setdiff(names, old_names)
[01:29:29.964]                 removed <- setdiff(old_names, names)
[01:29:29.964]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:29.964]                   envs[common]]
[01:29:29.964]                 NAMES <- toupper(changed)
[01:29:29.964]                 args <- list()
[01:29:29.964]                 for (kk in seq_along(NAMES)) {
[01:29:29.964]                   name <- changed[[kk]]
[01:29:29.964]                   NAME <- NAMES[[kk]]
[01:29:29.964]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.964]                     next
[01:29:29.964]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:29.964]                 }
[01:29:29.964]                 NAMES <- toupper(added)
[01:29:29.964]                 for (kk in seq_along(NAMES)) {
[01:29:29.964]                   name <- added[[kk]]
[01:29:29.964]                   NAME <- NAMES[[kk]]
[01:29:29.964]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.964]                     next
[01:29:29.964]                   args[[name]] <- ""
[01:29:29.964]                 }
[01:29:29.964]                 NAMES <- toupper(removed)
[01:29:29.964]                 for (kk in seq_along(NAMES)) {
[01:29:29.964]                   name <- removed[[kk]]
[01:29:29.964]                   NAME <- NAMES[[kk]]
[01:29:29.964]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.964]                     next
[01:29:29.964]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:29.964]                 }
[01:29:29.964]                 if (length(args) > 0) 
[01:29:29.964]                   base::do.call(base::Sys.setenv, args = args)
[01:29:29.964]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:29.964]             }
[01:29:29.964]             else {
[01:29:29.964]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:29.964]             }
[01:29:29.964]             {
[01:29:29.964]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:29.964]                   0L) {
[01:29:29.964]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:29.964]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:29.964]                   base::options(opts)
[01:29:29.964]                 }
[01:29:29.964]                 {
[01:29:29.964]                   {
[01:29:29.964]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:29.964]                     NULL
[01:29:29.964]                   }
[01:29:29.964]                   options(future.plan = NULL)
[01:29:29.964]                   if (is.na(NA_character_)) 
[01:29:29.964]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:29.964]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:29.964]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:29.964]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:29.964]                     envir = parent.frame()) 
[01:29:29.964]                   {
[01:29:29.964]                     if (is.function(workers)) 
[01:29:29.964]                       workers <- workers()
[01:29:29.964]                     workers <- structure(as.integer(workers), 
[01:29:29.964]                       class = class(workers))
[01:29:29.964]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:29.964]                       workers >= 1)
[01:29:29.964]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:29.964]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:29.964]                     }
[01:29:29.964]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:29.964]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:29.964]                       envir = envir)
[01:29:29.964]                     if (!future$lazy) 
[01:29:29.964]                       future <- run(future)
[01:29:29.964]                     invisible(future)
[01:29:29.964]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:29.964]                 }
[01:29:29.964]             }
[01:29:29.964]         }
[01:29:29.964]     })
[01:29:29.964]     if (TRUE) {
[01:29:29.964]         base::sink(type = "output", split = FALSE)
[01:29:29.964]         if (TRUE) {
[01:29:29.964]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:29.964]         }
[01:29:29.964]         else {
[01:29:29.964]             ...future.result["stdout"] <- base::list(NULL)
[01:29:29.964]         }
[01:29:29.964]         base::close(...future.stdout)
[01:29:29.964]         ...future.stdout <- NULL
[01:29:29.964]     }
[01:29:29.964]     ...future.result$conditions <- ...future.conditions
[01:29:29.964]     ...future.result$finished <- base::Sys.time()
[01:29:29.964]     ...future.result
[01:29:29.964] }
[01:29:29.970] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:29.970] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:29.971] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:29.971] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:29.972] MultisessionFuture started
[01:29:29.972] - Launch lazy future ... done
[01:29:29.972] run() for 'MultisessionFuture' ... done
[01:29:29.972] getGlobalsAndPackages() ...
[01:29:29.972] Searching for globals...
[01:29:29.974] - globals found: [3] '{', 'sample', 'x'
[01:29:29.974] Searching for globals ... DONE
[01:29:29.974] Resolving globals: FALSE
[01:29:29.975] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:29.975] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:29.976] - globals: [1] 'x'
[01:29:29.976] 
[01:29:29.976] getGlobalsAndPackages() ... DONE
[01:29:29.976] run() for 'Future' ...
[01:29:29.977] - state: 'created'
[01:29:29.977] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:29.992] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:29.992] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:29.992]   - Field: 'node'
[01:29:29.992]   - Field: 'label'
[01:29:29.993]   - Field: 'local'
[01:29:29.993]   - Field: 'owner'
[01:29:29.993]   - Field: 'envir'
[01:29:29.993]   - Field: 'workers'
[01:29:29.993]   - Field: 'packages'
[01:29:29.993]   - Field: 'gc'
[01:29:29.994]   - Field: 'conditions'
[01:29:29.994]   - Field: 'persistent'
[01:29:29.994]   - Field: 'expr'
[01:29:29.994]   - Field: 'uuid'
[01:29:29.994]   - Field: 'seed'
[01:29:29.995]   - Field: 'version'
[01:29:29.995]   - Field: 'result'
[01:29:29.995]   - Field: 'asynchronous'
[01:29:29.995]   - Field: 'calls'
[01:29:29.995]   - Field: 'globals'
[01:29:29.996]   - Field: 'stdout'
[01:29:29.996]   - Field: 'earlySignal'
[01:29:29.996]   - Field: 'lazy'
[01:29:29.996]   - Field: 'state'
[01:29:29.996] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:29.997] - Launch lazy future ...
[01:29:29.997] Packages needed by the future expression (n = 0): <none>
[01:29:29.997] Packages needed by future strategies (n = 0): <none>
[01:29:29.998] {
[01:29:29.998]     {
[01:29:29.998]         {
[01:29:29.998]             ...future.startTime <- base::Sys.time()
[01:29:29.998]             {
[01:29:29.998]                 {
[01:29:29.998]                   {
[01:29:29.998]                     {
[01:29:29.998]                       {
[01:29:29.998]                         base::local({
[01:29:29.998]                           has_future <- base::requireNamespace("future", 
[01:29:29.998]                             quietly = TRUE)
[01:29:29.998]                           if (has_future) {
[01:29:29.998]                             ns <- base::getNamespace("future")
[01:29:29.998]                             version <- ns[[".package"]][["version"]]
[01:29:29.998]                             if (is.null(version)) 
[01:29:29.998]                               version <- utils::packageVersion("future")
[01:29:29.998]                           }
[01:29:29.998]                           else {
[01:29:29.998]                             version <- NULL
[01:29:29.998]                           }
[01:29:29.998]                           if (!has_future || version < "1.8.0") {
[01:29:29.998]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:29.998]                               "", base::R.version$version.string), 
[01:29:29.998]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:29.998]                                 base::R.version$platform, 8 * 
[01:29:29.998]                                   base::.Machine$sizeof.pointer), 
[01:29:29.998]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:29.998]                                 "release", "version")], collapse = " "), 
[01:29:29.998]                               hostname = base::Sys.info()[["nodename"]])
[01:29:29.998]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:29.998]                               info)
[01:29:29.998]                             info <- base::paste(info, collapse = "; ")
[01:29:29.998]                             if (!has_future) {
[01:29:29.998]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:29.998]                                 info)
[01:29:29.998]                             }
[01:29:29.998]                             else {
[01:29:29.998]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:29.998]                                 info, version)
[01:29:29.998]                             }
[01:29:29.998]                             base::stop(msg)
[01:29:29.998]                           }
[01:29:29.998]                         })
[01:29:29.998]                       }
[01:29:29.998]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:29.998]                       base::options(mc.cores = 1L)
[01:29:29.998]                     }
[01:29:29.998]                     options(future.plan = NULL)
[01:29:29.998]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:29.998]                     future::plan("default", .cleanup = FALSE, 
[01:29:29.998]                       .init = FALSE)
[01:29:29.998]                   }
[01:29:29.998]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[01:29:29.998]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[01:29:29.998]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[01:29:29.998]                 }
[01:29:29.998]                 ...future.workdir <- getwd()
[01:29:29.998]             }
[01:29:29.998]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:29.998]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:29.998]         }
[01:29:29.998]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:29.998]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:29.998]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:29.998]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:29.998]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:29.998]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:29.998]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:29.998]             base::names(...future.oldOptions))
[01:29:29.998]     }
[01:29:29.998]     if (FALSE) {
[01:29:29.998]     }
[01:29:29.998]     else {
[01:29:29.998]         if (TRUE) {
[01:29:29.998]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:29.998]                 open = "w")
[01:29:29.998]         }
[01:29:29.998]         else {
[01:29:29.998]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:29.998]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:29.998]         }
[01:29:29.998]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:29.998]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:29.998]             base::sink(type = "output", split = FALSE)
[01:29:29.998]             base::close(...future.stdout)
[01:29:29.998]         }, add = TRUE)
[01:29:29.998]     }
[01:29:29.998]     ...future.frame <- base::sys.nframe()
[01:29:29.998]     ...future.conditions <- base::list()
[01:29:29.998]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:29.998]     if (FALSE) {
[01:29:29.998]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:29.998]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:29.998]     }
[01:29:29.998]     ...future.result <- base::tryCatch({
[01:29:29.998]         base::withCallingHandlers({
[01:29:29.998]             ...future.value <- base::withVisible(base::local({
[01:29:29.998]                 ...future.makeSendCondition <- base::local({
[01:29:29.998]                   sendCondition <- NULL
[01:29:29.998]                   function(frame = 1L) {
[01:29:29.998]                     if (is.function(sendCondition)) 
[01:29:29.998]                       return(sendCondition)
[01:29:29.998]                     ns <- getNamespace("parallel")
[01:29:29.998]                     if (exists("sendData", mode = "function", 
[01:29:29.998]                       envir = ns)) {
[01:29:29.998]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:29.998]                         envir = ns)
[01:29:29.998]                       envir <- sys.frame(frame)
[01:29:29.998]                       master <- NULL
[01:29:29.998]                       while (!identical(envir, .GlobalEnv) && 
[01:29:29.998]                         !identical(envir, emptyenv())) {
[01:29:29.998]                         if (exists("master", mode = "list", envir = envir, 
[01:29:29.998]                           inherits = FALSE)) {
[01:29:29.998]                           master <- get("master", mode = "list", 
[01:29:29.998]                             envir = envir, inherits = FALSE)
[01:29:29.998]                           if (inherits(master, c("SOCKnode", 
[01:29:29.998]                             "SOCK0node"))) {
[01:29:29.998]                             sendCondition <<- function(cond) {
[01:29:29.998]                               data <- list(type = "VALUE", value = cond, 
[01:29:29.998]                                 success = TRUE)
[01:29:29.998]                               parallel_sendData(master, data)
[01:29:29.998]                             }
[01:29:29.998]                             return(sendCondition)
[01:29:29.998]                           }
[01:29:29.998]                         }
[01:29:29.998]                         frame <- frame + 1L
[01:29:29.998]                         envir <- sys.frame(frame)
[01:29:29.998]                       }
[01:29:29.998]                     }
[01:29:29.998]                     sendCondition <<- function(cond) NULL
[01:29:29.998]                   }
[01:29:29.998]                 })
[01:29:29.998]                 withCallingHandlers({
[01:29:29.998]                   {
[01:29:29.998]                     sample(x, size = 1L)
[01:29:29.998]                   }
[01:29:29.998]                 }, immediateCondition = function(cond) {
[01:29:29.998]                   sendCondition <- ...future.makeSendCondition()
[01:29:29.998]                   sendCondition(cond)
[01:29:29.998]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.998]                   {
[01:29:29.998]                     inherits <- base::inherits
[01:29:29.998]                     invokeRestart <- base::invokeRestart
[01:29:29.998]                     is.null <- base::is.null
[01:29:29.998]                     muffled <- FALSE
[01:29:29.998]                     if (inherits(cond, "message")) {
[01:29:29.998]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:29.998]                       if (muffled) 
[01:29:29.998]                         invokeRestart("muffleMessage")
[01:29:29.998]                     }
[01:29:29.998]                     else if (inherits(cond, "warning")) {
[01:29:29.998]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:29.998]                       if (muffled) 
[01:29:29.998]                         invokeRestart("muffleWarning")
[01:29:29.998]                     }
[01:29:29.998]                     else if (inherits(cond, "condition")) {
[01:29:29.998]                       if (!is.null(pattern)) {
[01:29:29.998]                         computeRestarts <- base::computeRestarts
[01:29:29.998]                         grepl <- base::grepl
[01:29:29.998]                         restarts <- computeRestarts(cond)
[01:29:29.998]                         for (restart in restarts) {
[01:29:29.998]                           name <- restart$name
[01:29:29.998]                           if (is.null(name)) 
[01:29:29.998]                             next
[01:29:29.998]                           if (!grepl(pattern, name)) 
[01:29:29.998]                             next
[01:29:29.998]                           invokeRestart(restart)
[01:29:29.998]                           muffled <- TRUE
[01:29:29.998]                           break
[01:29:29.998]                         }
[01:29:29.998]                       }
[01:29:29.998]                     }
[01:29:29.998]                     invisible(muffled)
[01:29:29.998]                   }
[01:29:29.998]                   muffleCondition(cond)
[01:29:29.998]                 })
[01:29:29.998]             }))
[01:29:29.998]             future::FutureResult(value = ...future.value$value, 
[01:29:29.998]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:29.998]                   ...future.rng), globalenv = if (FALSE) 
[01:29:29.998]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:29.998]                     ...future.globalenv.names))
[01:29:29.998]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:29.998]         }, condition = base::local({
[01:29:29.998]             c <- base::c
[01:29:29.998]             inherits <- base::inherits
[01:29:29.998]             invokeRestart <- base::invokeRestart
[01:29:29.998]             length <- base::length
[01:29:29.998]             list <- base::list
[01:29:29.998]             seq.int <- base::seq.int
[01:29:29.998]             signalCondition <- base::signalCondition
[01:29:29.998]             sys.calls <- base::sys.calls
[01:29:29.998]             `[[` <- base::`[[`
[01:29:29.998]             `+` <- base::`+`
[01:29:29.998]             `<<-` <- base::`<<-`
[01:29:29.998]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:29.998]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:29.998]                   3L)]
[01:29:29.998]             }
[01:29:29.998]             function(cond) {
[01:29:29.998]                 is_error <- inherits(cond, "error")
[01:29:29.998]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:29.998]                   NULL)
[01:29:29.998]                 if (is_error) {
[01:29:29.998]                   sessionInformation <- function() {
[01:29:29.998]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:29.998]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:29.998]                       search = base::search(), system = base::Sys.info())
[01:29:29.998]                   }
[01:29:29.998]                   ...future.conditions[[length(...future.conditions) + 
[01:29:29.998]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:29.998]                     cond$call), session = sessionInformation(), 
[01:29:29.998]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:29.998]                   signalCondition(cond)
[01:29:29.998]                 }
[01:29:29.998]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:29.998]                 "immediateCondition"))) {
[01:29:29.998]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:29.998]                   ...future.conditions[[length(...future.conditions) + 
[01:29:29.998]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:29.998]                   if (TRUE && !signal) {
[01:29:29.998]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.998]                     {
[01:29:29.998]                       inherits <- base::inherits
[01:29:29.998]                       invokeRestart <- base::invokeRestart
[01:29:29.998]                       is.null <- base::is.null
[01:29:29.998]                       muffled <- FALSE
[01:29:29.998]                       if (inherits(cond, "message")) {
[01:29:29.998]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:29.998]                         if (muffled) 
[01:29:29.998]                           invokeRestart("muffleMessage")
[01:29:29.998]                       }
[01:29:29.998]                       else if (inherits(cond, "warning")) {
[01:29:29.998]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:29.998]                         if (muffled) 
[01:29:29.998]                           invokeRestart("muffleWarning")
[01:29:29.998]                       }
[01:29:29.998]                       else if (inherits(cond, "condition")) {
[01:29:29.998]                         if (!is.null(pattern)) {
[01:29:29.998]                           computeRestarts <- base::computeRestarts
[01:29:29.998]                           grepl <- base::grepl
[01:29:29.998]                           restarts <- computeRestarts(cond)
[01:29:29.998]                           for (restart in restarts) {
[01:29:29.998]                             name <- restart$name
[01:29:29.998]                             if (is.null(name)) 
[01:29:29.998]                               next
[01:29:29.998]                             if (!grepl(pattern, name)) 
[01:29:29.998]                               next
[01:29:29.998]                             invokeRestart(restart)
[01:29:29.998]                             muffled <- TRUE
[01:29:29.998]                             break
[01:29:29.998]                           }
[01:29:29.998]                         }
[01:29:29.998]                       }
[01:29:29.998]                       invisible(muffled)
[01:29:29.998]                     }
[01:29:29.998]                     muffleCondition(cond, pattern = "^muffle")
[01:29:29.998]                   }
[01:29:29.998]                 }
[01:29:29.998]                 else {
[01:29:29.998]                   if (TRUE) {
[01:29:29.998]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:29.998]                     {
[01:29:29.998]                       inherits <- base::inherits
[01:29:29.998]                       invokeRestart <- base::invokeRestart
[01:29:29.998]                       is.null <- base::is.null
[01:29:29.998]                       muffled <- FALSE
[01:29:29.998]                       if (inherits(cond, "message")) {
[01:29:29.998]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:29.998]                         if (muffled) 
[01:29:29.998]                           invokeRestart("muffleMessage")
[01:29:29.998]                       }
[01:29:29.998]                       else if (inherits(cond, "warning")) {
[01:29:29.998]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:29.998]                         if (muffled) 
[01:29:29.998]                           invokeRestart("muffleWarning")
[01:29:29.998]                       }
[01:29:29.998]                       else if (inherits(cond, "condition")) {
[01:29:29.998]                         if (!is.null(pattern)) {
[01:29:29.998]                           computeRestarts <- base::computeRestarts
[01:29:29.998]                           grepl <- base::grepl
[01:29:29.998]                           restarts <- computeRestarts(cond)
[01:29:29.998]                           for (restart in restarts) {
[01:29:29.998]                             name <- restart$name
[01:29:29.998]                             if (is.null(name)) 
[01:29:29.998]                               next
[01:29:29.998]                             if (!grepl(pattern, name)) 
[01:29:29.998]                               next
[01:29:29.998]                             invokeRestart(restart)
[01:29:29.998]                             muffled <- TRUE
[01:29:29.998]                             break
[01:29:29.998]                           }
[01:29:29.998]                         }
[01:29:29.998]                       }
[01:29:29.998]                       invisible(muffled)
[01:29:29.998]                     }
[01:29:29.998]                     muffleCondition(cond, pattern = "^muffle")
[01:29:29.998]                   }
[01:29:29.998]                 }
[01:29:29.998]             }
[01:29:29.998]         }))
[01:29:29.998]     }, error = function(ex) {
[01:29:29.998]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:29.998]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:29.998]                 ...future.rng), started = ...future.startTime, 
[01:29:29.998]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:29.998]             version = "1.8"), class = "FutureResult")
[01:29:29.998]     }, finally = {
[01:29:29.998]         if (!identical(...future.workdir, getwd())) 
[01:29:29.998]             setwd(...future.workdir)
[01:29:29.998]         {
[01:29:29.998]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:29.998]                 ...future.oldOptions$nwarnings <- NULL
[01:29:29.998]             }
[01:29:29.998]             base::options(...future.oldOptions)
[01:29:29.998]             if (.Platform$OS.type == "windows") {
[01:29:29.998]                 old_names <- names(...future.oldEnvVars)
[01:29:29.998]                 envs <- base::Sys.getenv()
[01:29:29.998]                 names <- names(envs)
[01:29:29.998]                 common <- intersect(names, old_names)
[01:29:29.998]                 added <- setdiff(names, old_names)
[01:29:29.998]                 removed <- setdiff(old_names, names)
[01:29:29.998]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:29.998]                   envs[common]]
[01:29:29.998]                 NAMES <- toupper(changed)
[01:29:29.998]                 args <- list()
[01:29:29.998]                 for (kk in seq_along(NAMES)) {
[01:29:29.998]                   name <- changed[[kk]]
[01:29:29.998]                   NAME <- NAMES[[kk]]
[01:29:29.998]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.998]                     next
[01:29:29.998]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:29.998]                 }
[01:29:29.998]                 NAMES <- toupper(added)
[01:29:29.998]                 for (kk in seq_along(NAMES)) {
[01:29:29.998]                   name <- added[[kk]]
[01:29:29.998]                   NAME <- NAMES[[kk]]
[01:29:29.998]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.998]                     next
[01:29:29.998]                   args[[name]] <- ""
[01:29:29.998]                 }
[01:29:29.998]                 NAMES <- toupper(removed)
[01:29:29.998]                 for (kk in seq_along(NAMES)) {
[01:29:29.998]                   name <- removed[[kk]]
[01:29:29.998]                   NAME <- NAMES[[kk]]
[01:29:29.998]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:29.998]                     next
[01:29:29.998]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:29.998]                 }
[01:29:29.998]                 if (length(args) > 0) 
[01:29:29.998]                   base::do.call(base::Sys.setenv, args = args)
[01:29:29.998]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:29.998]             }
[01:29:29.998]             else {
[01:29:29.998]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:29.998]             }
[01:29:29.998]             {
[01:29:29.998]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:29.998]                   0L) {
[01:29:29.998]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:29.998]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:29.998]                   base::options(opts)
[01:29:29.998]                 }
[01:29:29.998]                 {
[01:29:29.998]                   {
[01:29:29.998]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:29.998]                     NULL
[01:29:29.998]                   }
[01:29:29.998]                   options(future.plan = NULL)
[01:29:29.998]                   if (is.na(NA_character_)) 
[01:29:29.998]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:29.998]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:29.998]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:29.998]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:29.998]                     envir = parent.frame()) 
[01:29:29.998]                   {
[01:29:29.998]                     if (is.function(workers)) 
[01:29:29.998]                       workers <- workers()
[01:29:29.998]                     workers <- structure(as.integer(workers), 
[01:29:29.998]                       class = class(workers))
[01:29:29.998]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:29.998]                       workers >= 1)
[01:29:29.998]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:29.998]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:29.998]                     }
[01:29:29.998]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:29.998]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:29.998]                       envir = envir)
[01:29:29.998]                     if (!future$lazy) 
[01:29:29.998]                       future <- run(future)
[01:29:29.998]                     invisible(future)
[01:29:29.998]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:29.998]                 }
[01:29:29.998]             }
[01:29:29.998]         }
[01:29:29.998]     })
[01:29:29.998]     if (TRUE) {
[01:29:29.998]         base::sink(type = "output", split = FALSE)
[01:29:29.998]         if (TRUE) {
[01:29:29.998]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:29.998]         }
[01:29:29.998]         else {
[01:29:29.998]             ...future.result["stdout"] <- base::list(NULL)
[01:29:29.998]         }
[01:29:29.998]         base::close(...future.stdout)
[01:29:29.998]         ...future.stdout <- NULL
[01:29:29.998]     }
[01:29:29.998]     ...future.result$conditions <- ...future.conditions
[01:29:29.998]     ...future.result$finished <- base::Sys.time()
[01:29:29.998]     ...future.result
[01:29:29.998] }
[01:29:30.003] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:30.018] receiveMessageFromWorker() for ClusterFuture ...
[01:29:30.018] - Validating connection of MultisessionFuture
[01:29:30.019] - received message: FutureResult
[01:29:30.019] - Received FutureResult
[01:29:30.019] - Erased future from FutureRegistry
[01:29:30.019] result() for ClusterFuture ...
[01:29:30.019] - result already collected: FutureResult
[01:29:30.020] result() for ClusterFuture ... done
[01:29:30.020] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:30.020] result() for ClusterFuture ...
[01:29:30.020] - result already collected: FutureResult
[01:29:30.020] result() for ClusterFuture ... done
[01:29:30.021] result() for ClusterFuture ...
[01:29:30.021] - result already collected: FutureResult
[01:29:30.021] result() for ClusterFuture ... done
[01:29:30.022] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:30.022] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:30.022] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:30.023] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:30.023] MultisessionFuture started
[01:29:30.023] - Launch lazy future ... done
[01:29:30.027] run() for 'MultisessionFuture' ... done
[01:29:30.027] getGlobalsAndPackages() ...
[01:29:30.027] Searching for globals...
[01:29:30.029] - globals found: [3] '{', 'sample', 'x'
[01:29:30.029] Searching for globals ... DONE
[01:29:30.029] Resolving globals: FALSE
[01:29:30.030] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:30.030] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:30.030] - globals: [1] 'x'
[01:29:30.030] 
[01:29:30.031] getGlobalsAndPackages() ... DONE
[01:29:30.031] run() for 'Future' ...
[01:29:30.031] - state: 'created'
[01:29:30.031] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:30.046] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.046] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:30.046]   - Field: 'node'
[01:29:30.046]   - Field: 'label'
[01:29:30.046]   - Field: 'local'
[01:29:30.047]   - Field: 'owner'
[01:29:30.047]   - Field: 'envir'
[01:29:30.047]   - Field: 'workers'
[01:29:30.047]   - Field: 'packages'
[01:29:30.047]   - Field: 'gc'
[01:29:30.047]   - Field: 'conditions'
[01:29:30.048]   - Field: 'persistent'
[01:29:30.048]   - Field: 'expr'
[01:29:30.048]   - Field: 'uuid'
[01:29:30.048]   - Field: 'seed'
[01:29:30.048]   - Field: 'version'
[01:29:30.049]   - Field: 'result'
[01:29:30.049]   - Field: 'asynchronous'
[01:29:30.049]   - Field: 'calls'
[01:29:30.049]   - Field: 'globals'
[01:29:30.049]   - Field: 'stdout'
[01:29:30.049]   - Field: 'earlySignal'
[01:29:30.050]   - Field: 'lazy'
[01:29:30.050]   - Field: 'state'
[01:29:30.050] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:30.050] - Launch lazy future ...
[01:29:30.051] Packages needed by the future expression (n = 0): <none>
[01:29:30.051] Packages needed by future strategies (n = 0): <none>
[01:29:30.051] {
[01:29:30.051]     {
[01:29:30.051]         {
[01:29:30.051]             ...future.startTime <- base::Sys.time()
[01:29:30.051]             {
[01:29:30.051]                 {
[01:29:30.051]                   {
[01:29:30.051]                     {
[01:29:30.051]                       {
[01:29:30.051]                         base::local({
[01:29:30.051]                           has_future <- base::requireNamespace("future", 
[01:29:30.051]                             quietly = TRUE)
[01:29:30.051]                           if (has_future) {
[01:29:30.051]                             ns <- base::getNamespace("future")
[01:29:30.051]                             version <- ns[[".package"]][["version"]]
[01:29:30.051]                             if (is.null(version)) 
[01:29:30.051]                               version <- utils::packageVersion("future")
[01:29:30.051]                           }
[01:29:30.051]                           else {
[01:29:30.051]                             version <- NULL
[01:29:30.051]                           }
[01:29:30.051]                           if (!has_future || version < "1.8.0") {
[01:29:30.051]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:30.051]                               "", base::R.version$version.string), 
[01:29:30.051]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:30.051]                                 base::R.version$platform, 8 * 
[01:29:30.051]                                   base::.Machine$sizeof.pointer), 
[01:29:30.051]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:30.051]                                 "release", "version")], collapse = " "), 
[01:29:30.051]                               hostname = base::Sys.info()[["nodename"]])
[01:29:30.051]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:30.051]                               info)
[01:29:30.051]                             info <- base::paste(info, collapse = "; ")
[01:29:30.051]                             if (!has_future) {
[01:29:30.051]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:30.051]                                 info)
[01:29:30.051]                             }
[01:29:30.051]                             else {
[01:29:30.051]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:30.051]                                 info, version)
[01:29:30.051]                             }
[01:29:30.051]                             base::stop(msg)
[01:29:30.051]                           }
[01:29:30.051]                         })
[01:29:30.051]                       }
[01:29:30.051]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:30.051]                       base::options(mc.cores = 1L)
[01:29:30.051]                     }
[01:29:30.051]                     options(future.plan = NULL)
[01:29:30.051]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.051]                     future::plan("default", .cleanup = FALSE, 
[01:29:30.051]                       .init = FALSE)
[01:29:30.051]                   }
[01:29:30.051]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[01:29:30.051]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[01:29:30.051]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[01:29:30.051]                 }
[01:29:30.051]                 ...future.workdir <- getwd()
[01:29:30.051]             }
[01:29:30.051]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:30.051]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:30.051]         }
[01:29:30.051]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:30.051]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:30.051]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:30.051]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:30.051]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:30.051]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:30.051]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:30.051]             base::names(...future.oldOptions))
[01:29:30.051]     }
[01:29:30.051]     if (FALSE) {
[01:29:30.051]     }
[01:29:30.051]     else {
[01:29:30.051]         if (TRUE) {
[01:29:30.051]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:30.051]                 open = "w")
[01:29:30.051]         }
[01:29:30.051]         else {
[01:29:30.051]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:30.051]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:30.051]         }
[01:29:30.051]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:30.051]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:30.051]             base::sink(type = "output", split = FALSE)
[01:29:30.051]             base::close(...future.stdout)
[01:29:30.051]         }, add = TRUE)
[01:29:30.051]     }
[01:29:30.051]     ...future.frame <- base::sys.nframe()
[01:29:30.051]     ...future.conditions <- base::list()
[01:29:30.051]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:30.051]     if (FALSE) {
[01:29:30.051]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:30.051]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:30.051]     }
[01:29:30.051]     ...future.result <- base::tryCatch({
[01:29:30.051]         base::withCallingHandlers({
[01:29:30.051]             ...future.value <- base::withVisible(base::local({
[01:29:30.051]                 ...future.makeSendCondition <- base::local({
[01:29:30.051]                   sendCondition <- NULL
[01:29:30.051]                   function(frame = 1L) {
[01:29:30.051]                     if (is.function(sendCondition)) 
[01:29:30.051]                       return(sendCondition)
[01:29:30.051]                     ns <- getNamespace("parallel")
[01:29:30.051]                     if (exists("sendData", mode = "function", 
[01:29:30.051]                       envir = ns)) {
[01:29:30.051]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:30.051]                         envir = ns)
[01:29:30.051]                       envir <- sys.frame(frame)
[01:29:30.051]                       master <- NULL
[01:29:30.051]                       while (!identical(envir, .GlobalEnv) && 
[01:29:30.051]                         !identical(envir, emptyenv())) {
[01:29:30.051]                         if (exists("master", mode = "list", envir = envir, 
[01:29:30.051]                           inherits = FALSE)) {
[01:29:30.051]                           master <- get("master", mode = "list", 
[01:29:30.051]                             envir = envir, inherits = FALSE)
[01:29:30.051]                           if (inherits(master, c("SOCKnode", 
[01:29:30.051]                             "SOCK0node"))) {
[01:29:30.051]                             sendCondition <<- function(cond) {
[01:29:30.051]                               data <- list(type = "VALUE", value = cond, 
[01:29:30.051]                                 success = TRUE)
[01:29:30.051]                               parallel_sendData(master, data)
[01:29:30.051]                             }
[01:29:30.051]                             return(sendCondition)
[01:29:30.051]                           }
[01:29:30.051]                         }
[01:29:30.051]                         frame <- frame + 1L
[01:29:30.051]                         envir <- sys.frame(frame)
[01:29:30.051]                       }
[01:29:30.051]                     }
[01:29:30.051]                     sendCondition <<- function(cond) NULL
[01:29:30.051]                   }
[01:29:30.051]                 })
[01:29:30.051]                 withCallingHandlers({
[01:29:30.051]                   {
[01:29:30.051]                     sample(x, size = 1L)
[01:29:30.051]                   }
[01:29:30.051]                 }, immediateCondition = function(cond) {
[01:29:30.051]                   sendCondition <- ...future.makeSendCondition()
[01:29:30.051]                   sendCondition(cond)
[01:29:30.051]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.051]                   {
[01:29:30.051]                     inherits <- base::inherits
[01:29:30.051]                     invokeRestart <- base::invokeRestart
[01:29:30.051]                     is.null <- base::is.null
[01:29:30.051]                     muffled <- FALSE
[01:29:30.051]                     if (inherits(cond, "message")) {
[01:29:30.051]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:30.051]                       if (muffled) 
[01:29:30.051]                         invokeRestart("muffleMessage")
[01:29:30.051]                     }
[01:29:30.051]                     else if (inherits(cond, "warning")) {
[01:29:30.051]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:30.051]                       if (muffled) 
[01:29:30.051]                         invokeRestart("muffleWarning")
[01:29:30.051]                     }
[01:29:30.051]                     else if (inherits(cond, "condition")) {
[01:29:30.051]                       if (!is.null(pattern)) {
[01:29:30.051]                         computeRestarts <- base::computeRestarts
[01:29:30.051]                         grepl <- base::grepl
[01:29:30.051]                         restarts <- computeRestarts(cond)
[01:29:30.051]                         for (restart in restarts) {
[01:29:30.051]                           name <- restart$name
[01:29:30.051]                           if (is.null(name)) 
[01:29:30.051]                             next
[01:29:30.051]                           if (!grepl(pattern, name)) 
[01:29:30.051]                             next
[01:29:30.051]                           invokeRestart(restart)
[01:29:30.051]                           muffled <- TRUE
[01:29:30.051]                           break
[01:29:30.051]                         }
[01:29:30.051]                       }
[01:29:30.051]                     }
[01:29:30.051]                     invisible(muffled)
[01:29:30.051]                   }
[01:29:30.051]                   muffleCondition(cond)
[01:29:30.051]                 })
[01:29:30.051]             }))
[01:29:30.051]             future::FutureResult(value = ...future.value$value, 
[01:29:30.051]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.051]                   ...future.rng), globalenv = if (FALSE) 
[01:29:30.051]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:30.051]                     ...future.globalenv.names))
[01:29:30.051]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:30.051]         }, condition = base::local({
[01:29:30.051]             c <- base::c
[01:29:30.051]             inherits <- base::inherits
[01:29:30.051]             invokeRestart <- base::invokeRestart
[01:29:30.051]             length <- base::length
[01:29:30.051]             list <- base::list
[01:29:30.051]             seq.int <- base::seq.int
[01:29:30.051]             signalCondition <- base::signalCondition
[01:29:30.051]             sys.calls <- base::sys.calls
[01:29:30.051]             `[[` <- base::`[[`
[01:29:30.051]             `+` <- base::`+`
[01:29:30.051]             `<<-` <- base::`<<-`
[01:29:30.051]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:30.051]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:30.051]                   3L)]
[01:29:30.051]             }
[01:29:30.051]             function(cond) {
[01:29:30.051]                 is_error <- inherits(cond, "error")
[01:29:30.051]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:30.051]                   NULL)
[01:29:30.051]                 if (is_error) {
[01:29:30.051]                   sessionInformation <- function() {
[01:29:30.051]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:30.051]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:30.051]                       search = base::search(), system = base::Sys.info())
[01:29:30.051]                   }
[01:29:30.051]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.051]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:30.051]                     cond$call), session = sessionInformation(), 
[01:29:30.051]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:30.051]                   signalCondition(cond)
[01:29:30.051]                 }
[01:29:30.051]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:30.051]                 "immediateCondition"))) {
[01:29:30.051]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:30.051]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.051]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:30.051]                   if (TRUE && !signal) {
[01:29:30.051]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.051]                     {
[01:29:30.051]                       inherits <- base::inherits
[01:29:30.051]                       invokeRestart <- base::invokeRestart
[01:29:30.051]                       is.null <- base::is.null
[01:29:30.051]                       muffled <- FALSE
[01:29:30.051]                       if (inherits(cond, "message")) {
[01:29:30.051]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.051]                         if (muffled) 
[01:29:30.051]                           invokeRestart("muffleMessage")
[01:29:30.051]                       }
[01:29:30.051]                       else if (inherits(cond, "warning")) {
[01:29:30.051]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.051]                         if (muffled) 
[01:29:30.051]                           invokeRestart("muffleWarning")
[01:29:30.051]                       }
[01:29:30.051]                       else if (inherits(cond, "condition")) {
[01:29:30.051]                         if (!is.null(pattern)) {
[01:29:30.051]                           computeRestarts <- base::computeRestarts
[01:29:30.051]                           grepl <- base::grepl
[01:29:30.051]                           restarts <- computeRestarts(cond)
[01:29:30.051]                           for (restart in restarts) {
[01:29:30.051]                             name <- restart$name
[01:29:30.051]                             if (is.null(name)) 
[01:29:30.051]                               next
[01:29:30.051]                             if (!grepl(pattern, name)) 
[01:29:30.051]                               next
[01:29:30.051]                             invokeRestart(restart)
[01:29:30.051]                             muffled <- TRUE
[01:29:30.051]                             break
[01:29:30.051]                           }
[01:29:30.051]                         }
[01:29:30.051]                       }
[01:29:30.051]                       invisible(muffled)
[01:29:30.051]                     }
[01:29:30.051]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.051]                   }
[01:29:30.051]                 }
[01:29:30.051]                 else {
[01:29:30.051]                   if (TRUE) {
[01:29:30.051]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.051]                     {
[01:29:30.051]                       inherits <- base::inherits
[01:29:30.051]                       invokeRestart <- base::invokeRestart
[01:29:30.051]                       is.null <- base::is.null
[01:29:30.051]                       muffled <- FALSE
[01:29:30.051]                       if (inherits(cond, "message")) {
[01:29:30.051]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.051]                         if (muffled) 
[01:29:30.051]                           invokeRestart("muffleMessage")
[01:29:30.051]                       }
[01:29:30.051]                       else if (inherits(cond, "warning")) {
[01:29:30.051]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.051]                         if (muffled) 
[01:29:30.051]                           invokeRestart("muffleWarning")
[01:29:30.051]                       }
[01:29:30.051]                       else if (inherits(cond, "condition")) {
[01:29:30.051]                         if (!is.null(pattern)) {
[01:29:30.051]                           computeRestarts <- base::computeRestarts
[01:29:30.051]                           grepl <- base::grepl
[01:29:30.051]                           restarts <- computeRestarts(cond)
[01:29:30.051]                           for (restart in restarts) {
[01:29:30.051]                             name <- restart$name
[01:29:30.051]                             if (is.null(name)) 
[01:29:30.051]                               next
[01:29:30.051]                             if (!grepl(pattern, name)) 
[01:29:30.051]                               next
[01:29:30.051]                             invokeRestart(restart)
[01:29:30.051]                             muffled <- TRUE
[01:29:30.051]                             break
[01:29:30.051]                           }
[01:29:30.051]                         }
[01:29:30.051]                       }
[01:29:30.051]                       invisible(muffled)
[01:29:30.051]                     }
[01:29:30.051]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.051]                   }
[01:29:30.051]                 }
[01:29:30.051]             }
[01:29:30.051]         }))
[01:29:30.051]     }, error = function(ex) {
[01:29:30.051]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:30.051]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.051]                 ...future.rng), started = ...future.startTime, 
[01:29:30.051]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:30.051]             version = "1.8"), class = "FutureResult")
[01:29:30.051]     }, finally = {
[01:29:30.051]         if (!identical(...future.workdir, getwd())) 
[01:29:30.051]             setwd(...future.workdir)
[01:29:30.051]         {
[01:29:30.051]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:30.051]                 ...future.oldOptions$nwarnings <- NULL
[01:29:30.051]             }
[01:29:30.051]             base::options(...future.oldOptions)
[01:29:30.051]             if (.Platform$OS.type == "windows") {
[01:29:30.051]                 old_names <- names(...future.oldEnvVars)
[01:29:30.051]                 envs <- base::Sys.getenv()
[01:29:30.051]                 names <- names(envs)
[01:29:30.051]                 common <- intersect(names, old_names)
[01:29:30.051]                 added <- setdiff(names, old_names)
[01:29:30.051]                 removed <- setdiff(old_names, names)
[01:29:30.051]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:30.051]                   envs[common]]
[01:29:30.051]                 NAMES <- toupper(changed)
[01:29:30.051]                 args <- list()
[01:29:30.051]                 for (kk in seq_along(NAMES)) {
[01:29:30.051]                   name <- changed[[kk]]
[01:29:30.051]                   NAME <- NAMES[[kk]]
[01:29:30.051]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.051]                     next
[01:29:30.051]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.051]                 }
[01:29:30.051]                 NAMES <- toupper(added)
[01:29:30.051]                 for (kk in seq_along(NAMES)) {
[01:29:30.051]                   name <- added[[kk]]
[01:29:30.051]                   NAME <- NAMES[[kk]]
[01:29:30.051]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.051]                     next
[01:29:30.051]                   args[[name]] <- ""
[01:29:30.051]                 }
[01:29:30.051]                 NAMES <- toupper(removed)
[01:29:30.051]                 for (kk in seq_along(NAMES)) {
[01:29:30.051]                   name <- removed[[kk]]
[01:29:30.051]                   NAME <- NAMES[[kk]]
[01:29:30.051]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.051]                     next
[01:29:30.051]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.051]                 }
[01:29:30.051]                 if (length(args) > 0) 
[01:29:30.051]                   base::do.call(base::Sys.setenv, args = args)
[01:29:30.051]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:30.051]             }
[01:29:30.051]             else {
[01:29:30.051]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:30.051]             }
[01:29:30.051]             {
[01:29:30.051]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:30.051]                   0L) {
[01:29:30.051]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:30.051]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:30.051]                   base::options(opts)
[01:29:30.051]                 }
[01:29:30.051]                 {
[01:29:30.051]                   {
[01:29:30.051]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:30.051]                     NULL
[01:29:30.051]                   }
[01:29:30.051]                   options(future.plan = NULL)
[01:29:30.051]                   if (is.na(NA_character_)) 
[01:29:30.051]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.051]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:30.051]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:30.051]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:30.051]                     envir = parent.frame()) 
[01:29:30.051]                   {
[01:29:30.051]                     if (is.function(workers)) 
[01:29:30.051]                       workers <- workers()
[01:29:30.051]                     workers <- structure(as.integer(workers), 
[01:29:30.051]                       class = class(workers))
[01:29:30.051]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:30.051]                       workers >= 1)
[01:29:30.051]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:30.051]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:30.051]                     }
[01:29:30.051]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:30.051]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:30.051]                       envir = envir)
[01:29:30.051]                     if (!future$lazy) 
[01:29:30.051]                       future <- run(future)
[01:29:30.051]                     invisible(future)
[01:29:30.051]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:30.051]                 }
[01:29:30.051]             }
[01:29:30.051]         }
[01:29:30.051]     })
[01:29:30.051]     if (TRUE) {
[01:29:30.051]         base::sink(type = "output", split = FALSE)
[01:29:30.051]         if (TRUE) {
[01:29:30.051]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:30.051]         }
[01:29:30.051]         else {
[01:29:30.051]             ...future.result["stdout"] <- base::list(NULL)
[01:29:30.051]         }
[01:29:30.051]         base::close(...future.stdout)
[01:29:30.051]         ...future.stdout <- NULL
[01:29:30.051]     }
[01:29:30.051]     ...future.result$conditions <- ...future.conditions
[01:29:30.051]     ...future.result$finished <- base::Sys.time()
[01:29:30.051]     ...future.result
[01:29:30.051] }
[01:29:30.056] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:30.081] receiveMessageFromWorker() for ClusterFuture ...
[01:29:30.081] - Validating connection of MultisessionFuture
[01:29:30.081] - received message: FutureResult
[01:29:30.081] - Received FutureResult
[01:29:30.082] - Erased future from FutureRegistry
[01:29:30.082] result() for ClusterFuture ...
[01:29:30.082] - result already collected: FutureResult
[01:29:30.082] result() for ClusterFuture ... done
[01:29:30.082] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:30.082] result() for ClusterFuture ...
[01:29:30.083] - result already collected: FutureResult
[01:29:30.083] result() for ClusterFuture ... done
[01:29:30.083] result() for ClusterFuture ...
[01:29:30.083] - result already collected: FutureResult
[01:29:30.083] result() for ClusterFuture ... done
[01:29:30.084] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:30.084] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:30.085] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:30.085] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:30.085] MultisessionFuture started
[01:29:30.086] - Launch lazy future ... done
[01:29:30.086] run() for 'MultisessionFuture' ... done
[01:29:30.086] resolve() on list ...
[01:29:30.086]  recursive: 0
[01:29:30.087]  length: 4
[01:29:30.087] 
[01:29:30.087] Future #1
[01:29:30.087] result() for ClusterFuture ...
[01:29:30.087] - result already collected: FutureResult
[01:29:30.087] result() for ClusterFuture ... done
[01:29:30.088] result() for ClusterFuture ...
[01:29:30.088] - result already collected: FutureResult
[01:29:30.088] result() for ClusterFuture ... done
[01:29:30.088] signalConditionsASAP(MultisessionFuture, pos=1) ...
[01:29:30.088] - nx: 4
[01:29:30.089] - relay: TRUE
[01:29:30.089] - stdout: TRUE
[01:29:30.089] - signal: TRUE
[01:29:30.089] - resignal: FALSE
[01:29:30.089] - force: TRUE
[01:29:30.089] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:30.090] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:30.090]  - until=1
[01:29:30.090]  - relaying element #1
[01:29:30.090] result() for ClusterFuture ...
[01:29:30.090] - result already collected: FutureResult
[01:29:30.090] result() for ClusterFuture ... done
[01:29:30.091] result() for ClusterFuture ...
[01:29:30.091] - result already collected: FutureResult
[01:29:30.091] result() for ClusterFuture ... done
[01:29:30.091] result() for ClusterFuture ...
[01:29:30.091] - result already collected: FutureResult
[01:29:30.091] result() for ClusterFuture ... done
[01:29:30.092] result() for ClusterFuture ...
[01:29:30.092] - result already collected: FutureResult
[01:29:30.092] result() for ClusterFuture ... done
[01:29:30.092] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:30.092] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:30.093] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[01:29:30.093]  length: 3 (resolved future 1)
[01:29:30.093] Future #2
[01:29:30.093] result() for ClusterFuture ...
[01:29:30.093] - result already collected: FutureResult
[01:29:30.093] result() for ClusterFuture ... done
[01:29:30.094] result() for ClusterFuture ...
[01:29:30.094] - result already collected: FutureResult
[01:29:30.094] result() for ClusterFuture ... done
[01:29:30.094] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:29:30.094] - nx: 4
[01:29:30.095] - relay: TRUE
[01:29:30.095] - stdout: TRUE
[01:29:30.095] - signal: TRUE
[01:29:30.095] - resignal: FALSE
[01:29:30.095] - force: TRUE
[01:29:30.095] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:30.096] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:30.096]  - until=2
[01:29:30.096]  - relaying element #2
[01:29:30.096] result() for ClusterFuture ...
[01:29:30.096] - result already collected: FutureResult
[01:29:30.097] result() for ClusterFuture ... done
[01:29:30.097] result() for ClusterFuture ...
[01:29:30.097] - result already collected: FutureResult
[01:29:30.097] result() for ClusterFuture ... done
[01:29:30.097] result() for ClusterFuture ...
[01:29:30.098] - result already collected: FutureResult
[01:29:30.098] result() for ClusterFuture ... done
[01:29:30.098] result() for ClusterFuture ...
[01:29:30.098] - result already collected: FutureResult
[01:29:30.098] result() for ClusterFuture ... done
[01:29:30.098] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:30.099] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:30.099] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:29:30.099]  length: 2 (resolved future 2)
[01:29:30.099] receiveMessageFromWorker() for ClusterFuture ...
[01:29:30.100] - Validating connection of MultisessionFuture
[01:29:30.100] - received message: FutureResult
[01:29:30.100] - Received FutureResult
[01:29:30.100] - Erased future from FutureRegistry
[01:29:30.101] result() for ClusterFuture ...
[01:29:30.101] - result already collected: FutureResult
[01:29:30.101] result() for ClusterFuture ... done
[01:29:30.101] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:30.101] Future #3
[01:29:30.101] result() for ClusterFuture ...
[01:29:30.102] - result already collected: FutureResult
[01:29:30.102] result() for ClusterFuture ... done
[01:29:30.102] result() for ClusterFuture ...
[01:29:30.102] - result already collected: FutureResult
[01:29:30.102] result() for ClusterFuture ... done
[01:29:30.102] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:29:30.103] - nx: 4
[01:29:30.103] - relay: TRUE
[01:29:30.103] - stdout: TRUE
[01:29:30.103] - signal: TRUE
[01:29:30.103] - resignal: FALSE
[01:29:30.103] - force: TRUE
[01:29:30.104] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:30.104] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:30.104]  - until=3
[01:29:30.104]  - relaying element #3
[01:29:30.104] result() for ClusterFuture ...
[01:29:30.105] - result already collected: FutureResult
[01:29:30.105] result() for ClusterFuture ... done
[01:29:30.105] result() for ClusterFuture ...
[01:29:30.105] - result already collected: FutureResult
[01:29:30.105] result() for ClusterFuture ... done
[01:29:30.105] result() for ClusterFuture ...
[01:29:30.106] - result already collected: FutureResult
[01:29:30.106] result() for ClusterFuture ... done
[01:29:30.106] result() for ClusterFuture ...
[01:29:30.106] - result already collected: FutureResult
[01:29:30.107] result() for ClusterFuture ... done
[01:29:30.107] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:30.107] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:30.107] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:29:30.107]  length: 1 (resolved future 3)
[01:29:30.108] receiveMessageFromWorker() for ClusterFuture ...
[01:29:30.108] - Validating connection of MultisessionFuture
[01:29:30.108] - received message: FutureResult
[01:29:30.109] - Received FutureResult
[01:29:30.109] - Erased future from FutureRegistry
[01:29:30.109] result() for ClusterFuture ...
[01:29:30.109] - result already collected: FutureResult
[01:29:30.109] result() for ClusterFuture ... done
[01:29:30.109] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:30.110] Future #4
[01:29:30.110] result() for ClusterFuture ...
[01:29:30.110] - result already collected: FutureResult
[01:29:30.110] result() for ClusterFuture ... done
[01:29:30.110] result() for ClusterFuture ...
[01:29:30.110] - result already collected: FutureResult
[01:29:30.111] result() for ClusterFuture ... done
[01:29:30.111] signalConditionsASAP(MultisessionFuture, pos=4) ...
[01:29:30.111] - nx: 4
[01:29:30.111] - relay: TRUE
[01:29:30.111] - stdout: TRUE
[01:29:30.111] - signal: TRUE
[01:29:30.112] - resignal: FALSE
[01:29:30.112] - force: TRUE
[01:29:30.112] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:30.112] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:30.112]  - until=4
[01:29:30.112]  - relaying element #4
[01:29:30.113] result() for ClusterFuture ...
[01:29:30.113] - result already collected: FutureResult
[01:29:30.113] result() for ClusterFuture ... done
[01:29:30.113] result() for ClusterFuture ...
[01:29:30.113] - result already collected: FutureResult
[01:29:30.113] result() for ClusterFuture ... done
[01:29:30.114] result() for ClusterFuture ...
[01:29:30.114] - result already collected: FutureResult
[01:29:30.114] result() for ClusterFuture ... done
[01:29:30.114] result() for ClusterFuture ...
[01:29:30.114] - result already collected: FutureResult
[01:29:30.114] result() for ClusterFuture ... done
[01:29:30.115] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:30.115] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:30.115] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[01:29:30.115]  length: 0 (resolved future 4)
[01:29:30.115] Relaying remaining futures
[01:29:30.115] signalConditionsASAP(NULL, pos=0) ...
[01:29:30.116] - nx: 4
[01:29:30.116] - relay: TRUE
[01:29:30.116] - stdout: TRUE
[01:29:30.116] - signal: TRUE
[01:29:30.116] - resignal: FALSE
[01:29:30.116] - force: TRUE
[01:29:30.117] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:30.117] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[01:29:30.117] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:30.117] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:30.117] signalConditionsASAP(NULL, pos=0) ... done
[01:29:30.117] resolve() on list ... DONE
[01:29:30.118] result() for ClusterFuture ...
[01:29:30.118] - result already collected: FutureResult
[01:29:30.118] result() for ClusterFuture ... done
[01:29:30.118] result() for ClusterFuture ...
[01:29:30.118] - result already collected: FutureResult
[01:29:30.118] result() for ClusterFuture ... done
[01:29:30.119] result() for ClusterFuture ...
[01:29:30.119] - result already collected: FutureResult
[01:29:30.119] result() for ClusterFuture ... done
[01:29:30.119] result() for ClusterFuture ...
[01:29:30.119] - result already collected: FutureResult
[01:29:30.119] result() for ClusterFuture ... done
[01:29:30.120] result() for ClusterFuture ...
[01:29:30.120] - result already collected: FutureResult
[01:29:30.120] result() for ClusterFuture ... done
[01:29:30.120] result() for ClusterFuture ...
[01:29:30.120] - result already collected: FutureResult
[01:29:30.120] result() for ClusterFuture ... done
[01:29:30.121] result() for ClusterFuture ...
[01:29:30.121] - result already collected: FutureResult
[01:29:30.121] result() for ClusterFuture ... done
[01:29:30.121] result() for ClusterFuture ...
[01:29:30.121] - result already collected: FutureResult
[01:29:30.121] result() for ClusterFuture ... done
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[01:29:30.122] getGlobalsAndPackages() ...
[01:29:30.122] Searching for globals...
[01:29:30.123] - globals found: [3] '{', 'sample', 'x'
[01:29:30.124] Searching for globals ... DONE
[01:29:30.124] Resolving globals: FALSE
[01:29:30.125] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:30.125] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:30.125] - globals: [1] 'x'
[01:29:30.125] 
[01:29:30.126] getGlobalsAndPackages() ... DONE
[01:29:30.126] run() for 'Future' ...
[01:29:30.126] - state: 'created'
[01:29:30.126] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:30.141] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.142] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:30.142]   - Field: 'node'
[01:29:30.142]   - Field: 'label'
[01:29:30.142]   - Field: 'local'
[01:29:30.142]   - Field: 'owner'
[01:29:30.142]   - Field: 'envir'
[01:29:30.143]   - Field: 'workers'
[01:29:30.143]   - Field: 'packages'
[01:29:30.143]   - Field: 'gc'
[01:29:30.143]   - Field: 'conditions'
[01:29:30.143]   - Field: 'persistent'
[01:29:30.144]   - Field: 'expr'
[01:29:30.144]   - Field: 'uuid'
[01:29:30.144]   - Field: 'seed'
[01:29:30.144]   - Field: 'version'
[01:29:30.144]   - Field: 'result'
[01:29:30.144]   - Field: 'asynchronous'
[01:29:30.145]   - Field: 'calls'
[01:29:30.145]   - Field: 'globals'
[01:29:30.145]   - Field: 'stdout'
[01:29:30.145]   - Field: 'earlySignal'
[01:29:30.145]   - Field: 'lazy'
[01:29:30.145]   - Field: 'state'
[01:29:30.146] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:30.146] - Launch lazy future ...
[01:29:30.146] Packages needed by the future expression (n = 0): <none>
[01:29:30.146] Packages needed by future strategies (n = 0): <none>
[01:29:30.147] {
[01:29:30.147]     {
[01:29:30.147]         {
[01:29:30.147]             ...future.startTime <- base::Sys.time()
[01:29:30.147]             {
[01:29:30.147]                 {
[01:29:30.147]                   {
[01:29:30.147]                     {
[01:29:30.147]                       base::local({
[01:29:30.147]                         has_future <- base::requireNamespace("future", 
[01:29:30.147]                           quietly = TRUE)
[01:29:30.147]                         if (has_future) {
[01:29:30.147]                           ns <- base::getNamespace("future")
[01:29:30.147]                           version <- ns[[".package"]][["version"]]
[01:29:30.147]                           if (is.null(version)) 
[01:29:30.147]                             version <- utils::packageVersion("future")
[01:29:30.147]                         }
[01:29:30.147]                         else {
[01:29:30.147]                           version <- NULL
[01:29:30.147]                         }
[01:29:30.147]                         if (!has_future || version < "1.8.0") {
[01:29:30.147]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:30.147]                             "", base::R.version$version.string), 
[01:29:30.147]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:30.147]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:30.147]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:30.147]                               "release", "version")], collapse = " "), 
[01:29:30.147]                             hostname = base::Sys.info()[["nodename"]])
[01:29:30.147]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:30.147]                             info)
[01:29:30.147]                           info <- base::paste(info, collapse = "; ")
[01:29:30.147]                           if (!has_future) {
[01:29:30.147]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:30.147]                               info)
[01:29:30.147]                           }
[01:29:30.147]                           else {
[01:29:30.147]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:30.147]                               info, version)
[01:29:30.147]                           }
[01:29:30.147]                           base::stop(msg)
[01:29:30.147]                         }
[01:29:30.147]                       })
[01:29:30.147]                     }
[01:29:30.147]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:30.147]                     base::options(mc.cores = 1L)
[01:29:30.147]                   }
[01:29:30.147]                   options(future.plan = NULL)
[01:29:30.147]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.147]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:30.147]                 }
[01:29:30.147]                 ...future.workdir <- getwd()
[01:29:30.147]             }
[01:29:30.147]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:30.147]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:30.147]         }
[01:29:30.147]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:30.147]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:30.147]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:30.147]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:30.147]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:30.147]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:30.147]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:30.147]             base::names(...future.oldOptions))
[01:29:30.147]     }
[01:29:30.147]     if (FALSE) {
[01:29:30.147]     }
[01:29:30.147]     else {
[01:29:30.147]         if (TRUE) {
[01:29:30.147]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:30.147]                 open = "w")
[01:29:30.147]         }
[01:29:30.147]         else {
[01:29:30.147]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:30.147]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:30.147]         }
[01:29:30.147]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:30.147]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:30.147]             base::sink(type = "output", split = FALSE)
[01:29:30.147]             base::close(...future.stdout)
[01:29:30.147]         }, add = TRUE)
[01:29:30.147]     }
[01:29:30.147]     ...future.frame <- base::sys.nframe()
[01:29:30.147]     ...future.conditions <- base::list()
[01:29:30.147]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:30.147]     if (FALSE) {
[01:29:30.147]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:30.147]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:30.147]     }
[01:29:30.147]     ...future.result <- base::tryCatch({
[01:29:30.147]         base::withCallingHandlers({
[01:29:30.147]             ...future.value <- base::withVisible(base::local({
[01:29:30.147]                 ...future.makeSendCondition <- base::local({
[01:29:30.147]                   sendCondition <- NULL
[01:29:30.147]                   function(frame = 1L) {
[01:29:30.147]                     if (is.function(sendCondition)) 
[01:29:30.147]                       return(sendCondition)
[01:29:30.147]                     ns <- getNamespace("parallel")
[01:29:30.147]                     if (exists("sendData", mode = "function", 
[01:29:30.147]                       envir = ns)) {
[01:29:30.147]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:30.147]                         envir = ns)
[01:29:30.147]                       envir <- sys.frame(frame)
[01:29:30.147]                       master <- NULL
[01:29:30.147]                       while (!identical(envir, .GlobalEnv) && 
[01:29:30.147]                         !identical(envir, emptyenv())) {
[01:29:30.147]                         if (exists("master", mode = "list", envir = envir, 
[01:29:30.147]                           inherits = FALSE)) {
[01:29:30.147]                           master <- get("master", mode = "list", 
[01:29:30.147]                             envir = envir, inherits = FALSE)
[01:29:30.147]                           if (inherits(master, c("SOCKnode", 
[01:29:30.147]                             "SOCK0node"))) {
[01:29:30.147]                             sendCondition <<- function(cond) {
[01:29:30.147]                               data <- list(type = "VALUE", value = cond, 
[01:29:30.147]                                 success = TRUE)
[01:29:30.147]                               parallel_sendData(master, data)
[01:29:30.147]                             }
[01:29:30.147]                             return(sendCondition)
[01:29:30.147]                           }
[01:29:30.147]                         }
[01:29:30.147]                         frame <- frame + 1L
[01:29:30.147]                         envir <- sys.frame(frame)
[01:29:30.147]                       }
[01:29:30.147]                     }
[01:29:30.147]                     sendCondition <<- function(cond) NULL
[01:29:30.147]                   }
[01:29:30.147]                 })
[01:29:30.147]                 withCallingHandlers({
[01:29:30.147]                   {
[01:29:30.147]                     sample(x, size = 1L)
[01:29:30.147]                   }
[01:29:30.147]                 }, immediateCondition = function(cond) {
[01:29:30.147]                   sendCondition <- ...future.makeSendCondition()
[01:29:30.147]                   sendCondition(cond)
[01:29:30.147]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.147]                   {
[01:29:30.147]                     inherits <- base::inherits
[01:29:30.147]                     invokeRestart <- base::invokeRestart
[01:29:30.147]                     is.null <- base::is.null
[01:29:30.147]                     muffled <- FALSE
[01:29:30.147]                     if (inherits(cond, "message")) {
[01:29:30.147]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:30.147]                       if (muffled) 
[01:29:30.147]                         invokeRestart("muffleMessage")
[01:29:30.147]                     }
[01:29:30.147]                     else if (inherits(cond, "warning")) {
[01:29:30.147]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:30.147]                       if (muffled) 
[01:29:30.147]                         invokeRestart("muffleWarning")
[01:29:30.147]                     }
[01:29:30.147]                     else if (inherits(cond, "condition")) {
[01:29:30.147]                       if (!is.null(pattern)) {
[01:29:30.147]                         computeRestarts <- base::computeRestarts
[01:29:30.147]                         grepl <- base::grepl
[01:29:30.147]                         restarts <- computeRestarts(cond)
[01:29:30.147]                         for (restart in restarts) {
[01:29:30.147]                           name <- restart$name
[01:29:30.147]                           if (is.null(name)) 
[01:29:30.147]                             next
[01:29:30.147]                           if (!grepl(pattern, name)) 
[01:29:30.147]                             next
[01:29:30.147]                           invokeRestart(restart)
[01:29:30.147]                           muffled <- TRUE
[01:29:30.147]                           break
[01:29:30.147]                         }
[01:29:30.147]                       }
[01:29:30.147]                     }
[01:29:30.147]                     invisible(muffled)
[01:29:30.147]                   }
[01:29:30.147]                   muffleCondition(cond)
[01:29:30.147]                 })
[01:29:30.147]             }))
[01:29:30.147]             future::FutureResult(value = ...future.value$value, 
[01:29:30.147]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.147]                   ...future.rng), globalenv = if (FALSE) 
[01:29:30.147]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:30.147]                     ...future.globalenv.names))
[01:29:30.147]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:30.147]         }, condition = base::local({
[01:29:30.147]             c <- base::c
[01:29:30.147]             inherits <- base::inherits
[01:29:30.147]             invokeRestart <- base::invokeRestart
[01:29:30.147]             length <- base::length
[01:29:30.147]             list <- base::list
[01:29:30.147]             seq.int <- base::seq.int
[01:29:30.147]             signalCondition <- base::signalCondition
[01:29:30.147]             sys.calls <- base::sys.calls
[01:29:30.147]             `[[` <- base::`[[`
[01:29:30.147]             `+` <- base::`+`
[01:29:30.147]             `<<-` <- base::`<<-`
[01:29:30.147]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:30.147]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:30.147]                   3L)]
[01:29:30.147]             }
[01:29:30.147]             function(cond) {
[01:29:30.147]                 is_error <- inherits(cond, "error")
[01:29:30.147]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:30.147]                   NULL)
[01:29:30.147]                 if (is_error) {
[01:29:30.147]                   sessionInformation <- function() {
[01:29:30.147]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:30.147]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:30.147]                       search = base::search(), system = base::Sys.info())
[01:29:30.147]                   }
[01:29:30.147]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.147]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:30.147]                     cond$call), session = sessionInformation(), 
[01:29:30.147]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:30.147]                   signalCondition(cond)
[01:29:30.147]                 }
[01:29:30.147]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:30.147]                 "immediateCondition"))) {
[01:29:30.147]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:30.147]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.147]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:30.147]                   if (TRUE && !signal) {
[01:29:30.147]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.147]                     {
[01:29:30.147]                       inherits <- base::inherits
[01:29:30.147]                       invokeRestart <- base::invokeRestart
[01:29:30.147]                       is.null <- base::is.null
[01:29:30.147]                       muffled <- FALSE
[01:29:30.147]                       if (inherits(cond, "message")) {
[01:29:30.147]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.147]                         if (muffled) 
[01:29:30.147]                           invokeRestart("muffleMessage")
[01:29:30.147]                       }
[01:29:30.147]                       else if (inherits(cond, "warning")) {
[01:29:30.147]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.147]                         if (muffled) 
[01:29:30.147]                           invokeRestart("muffleWarning")
[01:29:30.147]                       }
[01:29:30.147]                       else if (inherits(cond, "condition")) {
[01:29:30.147]                         if (!is.null(pattern)) {
[01:29:30.147]                           computeRestarts <- base::computeRestarts
[01:29:30.147]                           grepl <- base::grepl
[01:29:30.147]                           restarts <- computeRestarts(cond)
[01:29:30.147]                           for (restart in restarts) {
[01:29:30.147]                             name <- restart$name
[01:29:30.147]                             if (is.null(name)) 
[01:29:30.147]                               next
[01:29:30.147]                             if (!grepl(pattern, name)) 
[01:29:30.147]                               next
[01:29:30.147]                             invokeRestart(restart)
[01:29:30.147]                             muffled <- TRUE
[01:29:30.147]                             break
[01:29:30.147]                           }
[01:29:30.147]                         }
[01:29:30.147]                       }
[01:29:30.147]                       invisible(muffled)
[01:29:30.147]                     }
[01:29:30.147]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.147]                   }
[01:29:30.147]                 }
[01:29:30.147]                 else {
[01:29:30.147]                   if (TRUE) {
[01:29:30.147]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.147]                     {
[01:29:30.147]                       inherits <- base::inherits
[01:29:30.147]                       invokeRestart <- base::invokeRestart
[01:29:30.147]                       is.null <- base::is.null
[01:29:30.147]                       muffled <- FALSE
[01:29:30.147]                       if (inherits(cond, "message")) {
[01:29:30.147]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.147]                         if (muffled) 
[01:29:30.147]                           invokeRestart("muffleMessage")
[01:29:30.147]                       }
[01:29:30.147]                       else if (inherits(cond, "warning")) {
[01:29:30.147]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.147]                         if (muffled) 
[01:29:30.147]                           invokeRestart("muffleWarning")
[01:29:30.147]                       }
[01:29:30.147]                       else if (inherits(cond, "condition")) {
[01:29:30.147]                         if (!is.null(pattern)) {
[01:29:30.147]                           computeRestarts <- base::computeRestarts
[01:29:30.147]                           grepl <- base::grepl
[01:29:30.147]                           restarts <- computeRestarts(cond)
[01:29:30.147]                           for (restart in restarts) {
[01:29:30.147]                             name <- restart$name
[01:29:30.147]                             if (is.null(name)) 
[01:29:30.147]                               next
[01:29:30.147]                             if (!grepl(pattern, name)) 
[01:29:30.147]                               next
[01:29:30.147]                             invokeRestart(restart)
[01:29:30.147]                             muffled <- TRUE
[01:29:30.147]                             break
[01:29:30.147]                           }
[01:29:30.147]                         }
[01:29:30.147]                       }
[01:29:30.147]                       invisible(muffled)
[01:29:30.147]                     }
[01:29:30.147]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.147]                   }
[01:29:30.147]                 }
[01:29:30.147]             }
[01:29:30.147]         }))
[01:29:30.147]     }, error = function(ex) {
[01:29:30.147]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:30.147]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.147]                 ...future.rng), started = ...future.startTime, 
[01:29:30.147]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:30.147]             version = "1.8"), class = "FutureResult")
[01:29:30.147]     }, finally = {
[01:29:30.147]         if (!identical(...future.workdir, getwd())) 
[01:29:30.147]             setwd(...future.workdir)
[01:29:30.147]         {
[01:29:30.147]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:30.147]                 ...future.oldOptions$nwarnings <- NULL
[01:29:30.147]             }
[01:29:30.147]             base::options(...future.oldOptions)
[01:29:30.147]             if (.Platform$OS.type == "windows") {
[01:29:30.147]                 old_names <- names(...future.oldEnvVars)
[01:29:30.147]                 envs <- base::Sys.getenv()
[01:29:30.147]                 names <- names(envs)
[01:29:30.147]                 common <- intersect(names, old_names)
[01:29:30.147]                 added <- setdiff(names, old_names)
[01:29:30.147]                 removed <- setdiff(old_names, names)
[01:29:30.147]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:30.147]                   envs[common]]
[01:29:30.147]                 NAMES <- toupper(changed)
[01:29:30.147]                 args <- list()
[01:29:30.147]                 for (kk in seq_along(NAMES)) {
[01:29:30.147]                   name <- changed[[kk]]
[01:29:30.147]                   NAME <- NAMES[[kk]]
[01:29:30.147]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.147]                     next
[01:29:30.147]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.147]                 }
[01:29:30.147]                 NAMES <- toupper(added)
[01:29:30.147]                 for (kk in seq_along(NAMES)) {
[01:29:30.147]                   name <- added[[kk]]
[01:29:30.147]                   NAME <- NAMES[[kk]]
[01:29:30.147]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.147]                     next
[01:29:30.147]                   args[[name]] <- ""
[01:29:30.147]                 }
[01:29:30.147]                 NAMES <- toupper(removed)
[01:29:30.147]                 for (kk in seq_along(NAMES)) {
[01:29:30.147]                   name <- removed[[kk]]
[01:29:30.147]                   NAME <- NAMES[[kk]]
[01:29:30.147]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.147]                     next
[01:29:30.147]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.147]                 }
[01:29:30.147]                 if (length(args) > 0) 
[01:29:30.147]                   base::do.call(base::Sys.setenv, args = args)
[01:29:30.147]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:30.147]             }
[01:29:30.147]             else {
[01:29:30.147]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:30.147]             }
[01:29:30.147]             {
[01:29:30.147]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:30.147]                   0L) {
[01:29:30.147]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:30.147]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:30.147]                   base::options(opts)
[01:29:30.147]                 }
[01:29:30.147]                 {
[01:29:30.147]                   {
[01:29:30.147]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:30.147]                     NULL
[01:29:30.147]                   }
[01:29:30.147]                   options(future.plan = NULL)
[01:29:30.147]                   if (is.na(NA_character_)) 
[01:29:30.147]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.147]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:30.147]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:30.147]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:30.147]                     envir = parent.frame()) 
[01:29:30.147]                   {
[01:29:30.147]                     if (is.function(workers)) 
[01:29:30.147]                       workers <- workers()
[01:29:30.147]                     workers <- structure(as.integer(workers), 
[01:29:30.147]                       class = class(workers))
[01:29:30.147]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:30.147]                       workers >= 1)
[01:29:30.147]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:30.147]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:30.147]                     }
[01:29:30.147]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:30.147]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:30.147]                       envir = envir)
[01:29:30.147]                     if (!future$lazy) 
[01:29:30.147]                       future <- run(future)
[01:29:30.147]                     invisible(future)
[01:29:30.147]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:30.147]                 }
[01:29:30.147]             }
[01:29:30.147]         }
[01:29:30.147]     })
[01:29:30.147]     if (TRUE) {
[01:29:30.147]         base::sink(type = "output", split = FALSE)
[01:29:30.147]         if (TRUE) {
[01:29:30.147]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:30.147]         }
[01:29:30.147]         else {
[01:29:30.147]             ...future.result["stdout"] <- base::list(NULL)
[01:29:30.147]         }
[01:29:30.147]         base::close(...future.stdout)
[01:29:30.147]         ...future.stdout <- NULL
[01:29:30.147]     }
[01:29:30.147]     ...future.result$conditions <- ...future.conditions
[01:29:30.147]     ...future.result$finished <- base::Sys.time()
[01:29:30.147]     ...future.result
[01:29:30.147] }
[01:29:30.152] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:30.153] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:30.153] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:30.153] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:30.154] MultisessionFuture started
[01:29:30.154] - Launch lazy future ... done
[01:29:30.154] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_1-340705'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96dd906f8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[01:29:30.171] receiveMessageFromWorker() for ClusterFuture ...
[01:29:30.171] - Validating connection of MultisessionFuture
[01:29:30.171] - received message: FutureResult
[01:29:30.172] - Received FutureResult
[01:29:30.172] - Erased future from FutureRegistry
[01:29:30.172] result() for ClusterFuture ...
[01:29:30.172] - result already collected: FutureResult
[01:29:30.172] result() for ClusterFuture ... done
[01:29:30.172] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.173] getGlobalsAndPackages() ...
[01:29:30.173] Searching for globals...
[01:29:30.174] - globals found: [3] '{', 'sample', 'x'
[01:29:30.175] Searching for globals ... DONE
[01:29:30.175] Resolving globals: FALSE
[01:29:30.176] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:30.176] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:30.176] - globals: [1] 'x'
[01:29:30.177] 
[01:29:30.177] getGlobalsAndPackages() ... DONE
[01:29:30.177] run() for 'Future' ...
[01:29:30.178] - state: 'created'
[01:29:30.178] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:30.193] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.194] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:30.194]   - Field: 'node'
[01:29:30.194]   - Field: 'label'
[01:29:30.194]   - Field: 'local'
[01:29:30.194]   - Field: 'owner'
[01:29:30.195]   - Field: 'envir'
[01:29:30.195]   - Field: 'workers'
[01:29:30.195]   - Field: 'packages'
[01:29:30.195]   - Field: 'gc'
[01:29:30.195]   - Field: 'conditions'
[01:29:30.196]   - Field: 'persistent'
[01:29:30.196]   - Field: 'expr'
[01:29:30.196]   - Field: 'uuid'
[01:29:30.196]   - Field: 'seed'
[01:29:30.196]   - Field: 'version'
[01:29:30.196]   - Field: 'result'
[01:29:30.197]   - Field: 'asynchronous'
[01:29:30.197]   - Field: 'calls'
[01:29:30.197]   - Field: 'globals'
[01:29:30.197]   - Field: 'stdout'
[01:29:30.197]   - Field: 'earlySignal'
[01:29:30.198]   - Field: 'lazy'
[01:29:30.198]   - Field: 'state'
[01:29:30.198] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:30.198] - Launch lazy future ...
[01:29:30.199] Packages needed by the future expression (n = 0): <none>
[01:29:30.199] Packages needed by future strategies (n = 0): <none>
[01:29:30.200] {
[01:29:30.200]     {
[01:29:30.200]         {
[01:29:30.200]             ...future.startTime <- base::Sys.time()
[01:29:30.200]             {
[01:29:30.200]                 {
[01:29:30.200]                   {
[01:29:30.200]                     {
[01:29:30.200]                       base::local({
[01:29:30.200]                         has_future <- base::requireNamespace("future", 
[01:29:30.200]                           quietly = TRUE)
[01:29:30.200]                         if (has_future) {
[01:29:30.200]                           ns <- base::getNamespace("future")
[01:29:30.200]                           version <- ns[[".package"]][["version"]]
[01:29:30.200]                           if (is.null(version)) 
[01:29:30.200]                             version <- utils::packageVersion("future")
[01:29:30.200]                         }
[01:29:30.200]                         else {
[01:29:30.200]                           version <- NULL
[01:29:30.200]                         }
[01:29:30.200]                         if (!has_future || version < "1.8.0") {
[01:29:30.200]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:30.200]                             "", base::R.version$version.string), 
[01:29:30.200]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:30.200]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:30.200]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:30.200]                               "release", "version")], collapse = " "), 
[01:29:30.200]                             hostname = base::Sys.info()[["nodename"]])
[01:29:30.200]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:30.200]                             info)
[01:29:30.200]                           info <- base::paste(info, collapse = "; ")
[01:29:30.200]                           if (!has_future) {
[01:29:30.200]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:30.200]                               info)
[01:29:30.200]                           }
[01:29:30.200]                           else {
[01:29:30.200]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:30.200]                               info, version)
[01:29:30.200]                           }
[01:29:30.200]                           base::stop(msg)
[01:29:30.200]                         }
[01:29:30.200]                       })
[01:29:30.200]                     }
[01:29:30.200]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:30.200]                     base::options(mc.cores = 1L)
[01:29:30.200]                   }
[01:29:30.200]                   options(future.plan = NULL)
[01:29:30.200]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.200]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:30.200]                 }
[01:29:30.200]                 ...future.workdir <- getwd()
[01:29:30.200]             }
[01:29:30.200]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:30.200]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:30.200]         }
[01:29:30.200]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:30.200]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:30.200]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:30.200]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:30.200]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:30.200]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:30.200]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:30.200]             base::names(...future.oldOptions))
[01:29:30.200]     }
[01:29:30.200]     if (FALSE) {
[01:29:30.200]     }
[01:29:30.200]     else {
[01:29:30.200]         if (TRUE) {
[01:29:30.200]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:30.200]                 open = "w")
[01:29:30.200]         }
[01:29:30.200]         else {
[01:29:30.200]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:30.200]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:30.200]         }
[01:29:30.200]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:30.200]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:30.200]             base::sink(type = "output", split = FALSE)
[01:29:30.200]             base::close(...future.stdout)
[01:29:30.200]         }, add = TRUE)
[01:29:30.200]     }
[01:29:30.200]     ...future.frame <- base::sys.nframe()
[01:29:30.200]     ...future.conditions <- base::list()
[01:29:30.200]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:30.200]     if (FALSE) {
[01:29:30.200]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:30.200]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:30.200]     }
[01:29:30.200]     ...future.result <- base::tryCatch({
[01:29:30.200]         base::withCallingHandlers({
[01:29:30.200]             ...future.value <- base::withVisible(base::local({
[01:29:30.200]                 ...future.makeSendCondition <- base::local({
[01:29:30.200]                   sendCondition <- NULL
[01:29:30.200]                   function(frame = 1L) {
[01:29:30.200]                     if (is.function(sendCondition)) 
[01:29:30.200]                       return(sendCondition)
[01:29:30.200]                     ns <- getNamespace("parallel")
[01:29:30.200]                     if (exists("sendData", mode = "function", 
[01:29:30.200]                       envir = ns)) {
[01:29:30.200]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:30.200]                         envir = ns)
[01:29:30.200]                       envir <- sys.frame(frame)
[01:29:30.200]                       master <- NULL
[01:29:30.200]                       while (!identical(envir, .GlobalEnv) && 
[01:29:30.200]                         !identical(envir, emptyenv())) {
[01:29:30.200]                         if (exists("master", mode = "list", envir = envir, 
[01:29:30.200]                           inherits = FALSE)) {
[01:29:30.200]                           master <- get("master", mode = "list", 
[01:29:30.200]                             envir = envir, inherits = FALSE)
[01:29:30.200]                           if (inherits(master, c("SOCKnode", 
[01:29:30.200]                             "SOCK0node"))) {
[01:29:30.200]                             sendCondition <<- function(cond) {
[01:29:30.200]                               data <- list(type = "VALUE", value = cond, 
[01:29:30.200]                                 success = TRUE)
[01:29:30.200]                               parallel_sendData(master, data)
[01:29:30.200]                             }
[01:29:30.200]                             return(sendCondition)
[01:29:30.200]                           }
[01:29:30.200]                         }
[01:29:30.200]                         frame <- frame + 1L
[01:29:30.200]                         envir <- sys.frame(frame)
[01:29:30.200]                       }
[01:29:30.200]                     }
[01:29:30.200]                     sendCondition <<- function(cond) NULL
[01:29:30.200]                   }
[01:29:30.200]                 })
[01:29:30.200]                 withCallingHandlers({
[01:29:30.200]                   {
[01:29:30.200]                     sample(x, size = 1L)
[01:29:30.200]                   }
[01:29:30.200]                 }, immediateCondition = function(cond) {
[01:29:30.200]                   sendCondition <- ...future.makeSendCondition()
[01:29:30.200]                   sendCondition(cond)
[01:29:30.200]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.200]                   {
[01:29:30.200]                     inherits <- base::inherits
[01:29:30.200]                     invokeRestart <- base::invokeRestart
[01:29:30.200]                     is.null <- base::is.null
[01:29:30.200]                     muffled <- FALSE
[01:29:30.200]                     if (inherits(cond, "message")) {
[01:29:30.200]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:30.200]                       if (muffled) 
[01:29:30.200]                         invokeRestart("muffleMessage")
[01:29:30.200]                     }
[01:29:30.200]                     else if (inherits(cond, "warning")) {
[01:29:30.200]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:30.200]                       if (muffled) 
[01:29:30.200]                         invokeRestart("muffleWarning")
[01:29:30.200]                     }
[01:29:30.200]                     else if (inherits(cond, "condition")) {
[01:29:30.200]                       if (!is.null(pattern)) {
[01:29:30.200]                         computeRestarts <- base::computeRestarts
[01:29:30.200]                         grepl <- base::grepl
[01:29:30.200]                         restarts <- computeRestarts(cond)
[01:29:30.200]                         for (restart in restarts) {
[01:29:30.200]                           name <- restart$name
[01:29:30.200]                           if (is.null(name)) 
[01:29:30.200]                             next
[01:29:30.200]                           if (!grepl(pattern, name)) 
[01:29:30.200]                             next
[01:29:30.200]                           invokeRestart(restart)
[01:29:30.200]                           muffled <- TRUE
[01:29:30.200]                           break
[01:29:30.200]                         }
[01:29:30.200]                       }
[01:29:30.200]                     }
[01:29:30.200]                     invisible(muffled)
[01:29:30.200]                   }
[01:29:30.200]                   muffleCondition(cond)
[01:29:30.200]                 })
[01:29:30.200]             }))
[01:29:30.200]             future::FutureResult(value = ...future.value$value, 
[01:29:30.200]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.200]                   ...future.rng), globalenv = if (FALSE) 
[01:29:30.200]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:30.200]                     ...future.globalenv.names))
[01:29:30.200]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:30.200]         }, condition = base::local({
[01:29:30.200]             c <- base::c
[01:29:30.200]             inherits <- base::inherits
[01:29:30.200]             invokeRestart <- base::invokeRestart
[01:29:30.200]             length <- base::length
[01:29:30.200]             list <- base::list
[01:29:30.200]             seq.int <- base::seq.int
[01:29:30.200]             signalCondition <- base::signalCondition
[01:29:30.200]             sys.calls <- base::sys.calls
[01:29:30.200]             `[[` <- base::`[[`
[01:29:30.200]             `+` <- base::`+`
[01:29:30.200]             `<<-` <- base::`<<-`
[01:29:30.200]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:30.200]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:30.200]                   3L)]
[01:29:30.200]             }
[01:29:30.200]             function(cond) {
[01:29:30.200]                 is_error <- inherits(cond, "error")
[01:29:30.200]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:30.200]                   NULL)
[01:29:30.200]                 if (is_error) {
[01:29:30.200]                   sessionInformation <- function() {
[01:29:30.200]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:30.200]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:30.200]                       search = base::search(), system = base::Sys.info())
[01:29:30.200]                   }
[01:29:30.200]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.200]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:30.200]                     cond$call), session = sessionInformation(), 
[01:29:30.200]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:30.200]                   signalCondition(cond)
[01:29:30.200]                 }
[01:29:30.200]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:30.200]                 "immediateCondition"))) {
[01:29:30.200]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:30.200]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.200]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:30.200]                   if (TRUE && !signal) {
[01:29:30.200]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.200]                     {
[01:29:30.200]                       inherits <- base::inherits
[01:29:30.200]                       invokeRestart <- base::invokeRestart
[01:29:30.200]                       is.null <- base::is.null
[01:29:30.200]                       muffled <- FALSE
[01:29:30.200]                       if (inherits(cond, "message")) {
[01:29:30.200]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.200]                         if (muffled) 
[01:29:30.200]                           invokeRestart("muffleMessage")
[01:29:30.200]                       }
[01:29:30.200]                       else if (inherits(cond, "warning")) {
[01:29:30.200]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.200]                         if (muffled) 
[01:29:30.200]                           invokeRestart("muffleWarning")
[01:29:30.200]                       }
[01:29:30.200]                       else if (inherits(cond, "condition")) {
[01:29:30.200]                         if (!is.null(pattern)) {
[01:29:30.200]                           computeRestarts <- base::computeRestarts
[01:29:30.200]                           grepl <- base::grepl
[01:29:30.200]                           restarts <- computeRestarts(cond)
[01:29:30.200]                           for (restart in restarts) {
[01:29:30.200]                             name <- restart$name
[01:29:30.200]                             if (is.null(name)) 
[01:29:30.200]                               next
[01:29:30.200]                             if (!grepl(pattern, name)) 
[01:29:30.200]                               next
[01:29:30.200]                             invokeRestart(restart)
[01:29:30.200]                             muffled <- TRUE
[01:29:30.200]                             break
[01:29:30.200]                           }
[01:29:30.200]                         }
[01:29:30.200]                       }
[01:29:30.200]                       invisible(muffled)
[01:29:30.200]                     }
[01:29:30.200]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.200]                   }
[01:29:30.200]                 }
[01:29:30.200]                 else {
[01:29:30.200]                   if (TRUE) {
[01:29:30.200]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.200]                     {
[01:29:30.200]                       inherits <- base::inherits
[01:29:30.200]                       invokeRestart <- base::invokeRestart
[01:29:30.200]                       is.null <- base::is.null
[01:29:30.200]                       muffled <- FALSE
[01:29:30.200]                       if (inherits(cond, "message")) {
[01:29:30.200]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.200]                         if (muffled) 
[01:29:30.200]                           invokeRestart("muffleMessage")
[01:29:30.200]                       }
[01:29:30.200]                       else if (inherits(cond, "warning")) {
[01:29:30.200]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.200]                         if (muffled) 
[01:29:30.200]                           invokeRestart("muffleWarning")
[01:29:30.200]                       }
[01:29:30.200]                       else if (inherits(cond, "condition")) {
[01:29:30.200]                         if (!is.null(pattern)) {
[01:29:30.200]                           computeRestarts <- base::computeRestarts
[01:29:30.200]                           grepl <- base::grepl
[01:29:30.200]                           restarts <- computeRestarts(cond)
[01:29:30.200]                           for (restart in restarts) {
[01:29:30.200]                             name <- restart$name
[01:29:30.200]                             if (is.null(name)) 
[01:29:30.200]                               next
[01:29:30.200]                             if (!grepl(pattern, name)) 
[01:29:30.200]                               next
[01:29:30.200]                             invokeRestart(restart)
[01:29:30.200]                             muffled <- TRUE
[01:29:30.200]                             break
[01:29:30.200]                           }
[01:29:30.200]                         }
[01:29:30.200]                       }
[01:29:30.200]                       invisible(muffled)
[01:29:30.200]                     }
[01:29:30.200]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.200]                   }
[01:29:30.200]                 }
[01:29:30.200]             }
[01:29:30.200]         }))
[01:29:30.200]     }, error = function(ex) {
[01:29:30.200]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:30.200]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.200]                 ...future.rng), started = ...future.startTime, 
[01:29:30.200]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:30.200]             version = "1.8"), class = "FutureResult")
[01:29:30.200]     }, finally = {
[01:29:30.200]         if (!identical(...future.workdir, getwd())) 
[01:29:30.200]             setwd(...future.workdir)
[01:29:30.200]         {
[01:29:30.200]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:30.200]                 ...future.oldOptions$nwarnings <- NULL
[01:29:30.200]             }
[01:29:30.200]             base::options(...future.oldOptions)
[01:29:30.200]             if (.Platform$OS.type == "windows") {
[01:29:30.200]                 old_names <- names(...future.oldEnvVars)
[01:29:30.200]                 envs <- base::Sys.getenv()
[01:29:30.200]                 names <- names(envs)
[01:29:30.200]                 common <- intersect(names, old_names)
[01:29:30.200]                 added <- setdiff(names, old_names)
[01:29:30.200]                 removed <- setdiff(old_names, names)
[01:29:30.200]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:30.200]                   envs[common]]
[01:29:30.200]                 NAMES <- toupper(changed)
[01:29:30.200]                 args <- list()
[01:29:30.200]                 for (kk in seq_along(NAMES)) {
[01:29:30.200]                   name <- changed[[kk]]
[01:29:30.200]                   NAME <- NAMES[[kk]]
[01:29:30.200]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.200]                     next
[01:29:30.200]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.200]                 }
[01:29:30.200]                 NAMES <- toupper(added)
[01:29:30.200]                 for (kk in seq_along(NAMES)) {
[01:29:30.200]                   name <- added[[kk]]
[01:29:30.200]                   NAME <- NAMES[[kk]]
[01:29:30.200]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.200]                     next
[01:29:30.200]                   args[[name]] <- ""
[01:29:30.200]                 }
[01:29:30.200]                 NAMES <- toupper(removed)
[01:29:30.200]                 for (kk in seq_along(NAMES)) {
[01:29:30.200]                   name <- removed[[kk]]
[01:29:30.200]                   NAME <- NAMES[[kk]]
[01:29:30.200]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.200]                     next
[01:29:30.200]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.200]                 }
[01:29:30.200]                 if (length(args) > 0) 
[01:29:30.200]                   base::do.call(base::Sys.setenv, args = args)
[01:29:30.200]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:30.200]             }
[01:29:30.200]             else {
[01:29:30.200]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:30.200]             }
[01:29:30.200]             {
[01:29:30.200]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:30.200]                   0L) {
[01:29:30.200]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:30.200]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:30.200]                   base::options(opts)
[01:29:30.200]                 }
[01:29:30.200]                 {
[01:29:30.200]                   {
[01:29:30.200]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:30.200]                     NULL
[01:29:30.200]                   }
[01:29:30.200]                   options(future.plan = NULL)
[01:29:30.200]                   if (is.na(NA_character_)) 
[01:29:30.200]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.200]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:30.200]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:30.200]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:30.200]                     envir = parent.frame()) 
[01:29:30.200]                   {
[01:29:30.200]                     if (is.function(workers)) 
[01:29:30.200]                       workers <- workers()
[01:29:30.200]                     workers <- structure(as.integer(workers), 
[01:29:30.200]                       class = class(workers))
[01:29:30.200]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:30.200]                       workers >= 1)
[01:29:30.200]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:30.200]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:30.200]                     }
[01:29:30.200]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:30.200]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:30.200]                       envir = envir)
[01:29:30.200]                     if (!future$lazy) 
[01:29:30.200]                       future <- run(future)
[01:29:30.200]                     invisible(future)
[01:29:30.200]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:30.200]                 }
[01:29:30.200]             }
[01:29:30.200]         }
[01:29:30.200]     })
[01:29:30.200]     if (TRUE) {
[01:29:30.200]         base::sink(type = "output", split = FALSE)
[01:29:30.200]         if (TRUE) {
[01:29:30.200]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:30.200]         }
[01:29:30.200]         else {
[01:29:30.200]             ...future.result["stdout"] <- base::list(NULL)
[01:29:30.200]         }
[01:29:30.200]         base::close(...future.stdout)
[01:29:30.200]         ...future.stdout <- NULL
[01:29:30.200]     }
[01:29:30.200]     ...future.result$conditions <- ...future.conditions
[01:29:30.200]     ...future.result$finished <- base::Sys.time()
[01:29:30.200]     ...future.result
[01:29:30.200] }
[01:29:30.205] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:30.206] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:30.206] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:30.207] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:30.207] MultisessionFuture started
[01:29:30.208] - Launch lazy future ... done
[01:29:30.208] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_2-849338'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96dd906f8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[01:29:30.224] receiveMessageFromWorker() for ClusterFuture ...
[01:29:30.225] - Validating connection of MultisessionFuture
[01:29:30.225] - received message: FutureResult
[01:29:30.225] - Received FutureResult
[01:29:30.225] - Erased future from FutureRegistry
[01:29:30.225] result() for ClusterFuture ...
[01:29:30.226] - result already collected: FutureResult
[01:29:30.226] result() for ClusterFuture ... done
[01:29:30.226] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.226] getGlobalsAndPackages() ...
[01:29:30.226] Searching for globals...
[01:29:30.228] - globals found: [3] '{', 'sample', 'x'
[01:29:30.228] Searching for globals ... DONE
[01:29:30.228] Resolving globals: FALSE
[01:29:30.228] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:30.229] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:30.229] - globals: [1] 'x'
[01:29:30.229] 
[01:29:30.229] getGlobalsAndPackages() ... DONE
[01:29:30.230] run() for 'Future' ...
[01:29:30.230] - state: 'created'
[01:29:30.230] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:30.245] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.245] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:30.246]   - Field: 'node'
[01:29:30.246]   - Field: 'label'
[01:29:30.246]   - Field: 'local'
[01:29:30.246]   - Field: 'owner'
[01:29:30.246]   - Field: 'envir'
[01:29:30.246]   - Field: 'workers'
[01:29:30.247]   - Field: 'packages'
[01:29:30.247]   - Field: 'gc'
[01:29:30.247]   - Field: 'conditions'
[01:29:30.247]   - Field: 'persistent'
[01:29:30.247]   - Field: 'expr'
[01:29:30.248]   - Field: 'uuid'
[01:29:30.248]   - Field: 'seed'
[01:29:30.248]   - Field: 'version'
[01:29:30.248]   - Field: 'result'
[01:29:30.248]   - Field: 'asynchronous'
[01:29:30.248]   - Field: 'calls'
[01:29:30.249]   - Field: 'globals'
[01:29:30.249]   - Field: 'stdout'
[01:29:30.249]   - Field: 'earlySignal'
[01:29:30.249]   - Field: 'lazy'
[01:29:30.249]   - Field: 'state'
[01:29:30.249] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:30.250] - Launch lazy future ...
[01:29:30.250] Packages needed by the future expression (n = 0): <none>
[01:29:30.250] Packages needed by future strategies (n = 0): <none>
[01:29:30.251] {
[01:29:30.251]     {
[01:29:30.251]         {
[01:29:30.251]             ...future.startTime <- base::Sys.time()
[01:29:30.251]             {
[01:29:30.251]                 {
[01:29:30.251]                   {
[01:29:30.251]                     {
[01:29:30.251]                       base::local({
[01:29:30.251]                         has_future <- base::requireNamespace("future", 
[01:29:30.251]                           quietly = TRUE)
[01:29:30.251]                         if (has_future) {
[01:29:30.251]                           ns <- base::getNamespace("future")
[01:29:30.251]                           version <- ns[[".package"]][["version"]]
[01:29:30.251]                           if (is.null(version)) 
[01:29:30.251]                             version <- utils::packageVersion("future")
[01:29:30.251]                         }
[01:29:30.251]                         else {
[01:29:30.251]                           version <- NULL
[01:29:30.251]                         }
[01:29:30.251]                         if (!has_future || version < "1.8.0") {
[01:29:30.251]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:30.251]                             "", base::R.version$version.string), 
[01:29:30.251]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:30.251]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:30.251]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:30.251]                               "release", "version")], collapse = " "), 
[01:29:30.251]                             hostname = base::Sys.info()[["nodename"]])
[01:29:30.251]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:30.251]                             info)
[01:29:30.251]                           info <- base::paste(info, collapse = "; ")
[01:29:30.251]                           if (!has_future) {
[01:29:30.251]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:30.251]                               info)
[01:29:30.251]                           }
[01:29:30.251]                           else {
[01:29:30.251]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:30.251]                               info, version)
[01:29:30.251]                           }
[01:29:30.251]                           base::stop(msg)
[01:29:30.251]                         }
[01:29:30.251]                       })
[01:29:30.251]                     }
[01:29:30.251]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:30.251]                     base::options(mc.cores = 1L)
[01:29:30.251]                   }
[01:29:30.251]                   options(future.plan = NULL)
[01:29:30.251]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.251]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:30.251]                 }
[01:29:30.251]                 ...future.workdir <- getwd()
[01:29:30.251]             }
[01:29:30.251]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:30.251]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:30.251]         }
[01:29:30.251]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:30.251]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:30.251]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:30.251]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:30.251]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:30.251]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:30.251]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:30.251]             base::names(...future.oldOptions))
[01:29:30.251]     }
[01:29:30.251]     if (FALSE) {
[01:29:30.251]     }
[01:29:30.251]     else {
[01:29:30.251]         if (TRUE) {
[01:29:30.251]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:30.251]                 open = "w")
[01:29:30.251]         }
[01:29:30.251]         else {
[01:29:30.251]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:30.251]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:30.251]         }
[01:29:30.251]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:30.251]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:30.251]             base::sink(type = "output", split = FALSE)
[01:29:30.251]             base::close(...future.stdout)
[01:29:30.251]         }, add = TRUE)
[01:29:30.251]     }
[01:29:30.251]     ...future.frame <- base::sys.nframe()
[01:29:30.251]     ...future.conditions <- base::list()
[01:29:30.251]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:30.251]     if (FALSE) {
[01:29:30.251]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:30.251]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:30.251]     }
[01:29:30.251]     ...future.result <- base::tryCatch({
[01:29:30.251]         base::withCallingHandlers({
[01:29:30.251]             ...future.value <- base::withVisible(base::local({
[01:29:30.251]                 ...future.makeSendCondition <- base::local({
[01:29:30.251]                   sendCondition <- NULL
[01:29:30.251]                   function(frame = 1L) {
[01:29:30.251]                     if (is.function(sendCondition)) 
[01:29:30.251]                       return(sendCondition)
[01:29:30.251]                     ns <- getNamespace("parallel")
[01:29:30.251]                     if (exists("sendData", mode = "function", 
[01:29:30.251]                       envir = ns)) {
[01:29:30.251]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:30.251]                         envir = ns)
[01:29:30.251]                       envir <- sys.frame(frame)
[01:29:30.251]                       master <- NULL
[01:29:30.251]                       while (!identical(envir, .GlobalEnv) && 
[01:29:30.251]                         !identical(envir, emptyenv())) {
[01:29:30.251]                         if (exists("master", mode = "list", envir = envir, 
[01:29:30.251]                           inherits = FALSE)) {
[01:29:30.251]                           master <- get("master", mode = "list", 
[01:29:30.251]                             envir = envir, inherits = FALSE)
[01:29:30.251]                           if (inherits(master, c("SOCKnode", 
[01:29:30.251]                             "SOCK0node"))) {
[01:29:30.251]                             sendCondition <<- function(cond) {
[01:29:30.251]                               data <- list(type = "VALUE", value = cond, 
[01:29:30.251]                                 success = TRUE)
[01:29:30.251]                               parallel_sendData(master, data)
[01:29:30.251]                             }
[01:29:30.251]                             return(sendCondition)
[01:29:30.251]                           }
[01:29:30.251]                         }
[01:29:30.251]                         frame <- frame + 1L
[01:29:30.251]                         envir <- sys.frame(frame)
[01:29:30.251]                       }
[01:29:30.251]                     }
[01:29:30.251]                     sendCondition <<- function(cond) NULL
[01:29:30.251]                   }
[01:29:30.251]                 })
[01:29:30.251]                 withCallingHandlers({
[01:29:30.251]                   {
[01:29:30.251]                     sample(x, size = 1L)
[01:29:30.251]                   }
[01:29:30.251]                 }, immediateCondition = function(cond) {
[01:29:30.251]                   sendCondition <- ...future.makeSendCondition()
[01:29:30.251]                   sendCondition(cond)
[01:29:30.251]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.251]                   {
[01:29:30.251]                     inherits <- base::inherits
[01:29:30.251]                     invokeRestart <- base::invokeRestart
[01:29:30.251]                     is.null <- base::is.null
[01:29:30.251]                     muffled <- FALSE
[01:29:30.251]                     if (inherits(cond, "message")) {
[01:29:30.251]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:30.251]                       if (muffled) 
[01:29:30.251]                         invokeRestart("muffleMessage")
[01:29:30.251]                     }
[01:29:30.251]                     else if (inherits(cond, "warning")) {
[01:29:30.251]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:30.251]                       if (muffled) 
[01:29:30.251]                         invokeRestart("muffleWarning")
[01:29:30.251]                     }
[01:29:30.251]                     else if (inherits(cond, "condition")) {
[01:29:30.251]                       if (!is.null(pattern)) {
[01:29:30.251]                         computeRestarts <- base::computeRestarts
[01:29:30.251]                         grepl <- base::grepl
[01:29:30.251]                         restarts <- computeRestarts(cond)
[01:29:30.251]                         for (restart in restarts) {
[01:29:30.251]                           name <- restart$name
[01:29:30.251]                           if (is.null(name)) 
[01:29:30.251]                             next
[01:29:30.251]                           if (!grepl(pattern, name)) 
[01:29:30.251]                             next
[01:29:30.251]                           invokeRestart(restart)
[01:29:30.251]                           muffled <- TRUE
[01:29:30.251]                           break
[01:29:30.251]                         }
[01:29:30.251]                       }
[01:29:30.251]                     }
[01:29:30.251]                     invisible(muffled)
[01:29:30.251]                   }
[01:29:30.251]                   muffleCondition(cond)
[01:29:30.251]                 })
[01:29:30.251]             }))
[01:29:30.251]             future::FutureResult(value = ...future.value$value, 
[01:29:30.251]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.251]                   ...future.rng), globalenv = if (FALSE) 
[01:29:30.251]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:30.251]                     ...future.globalenv.names))
[01:29:30.251]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:30.251]         }, condition = base::local({
[01:29:30.251]             c <- base::c
[01:29:30.251]             inherits <- base::inherits
[01:29:30.251]             invokeRestart <- base::invokeRestart
[01:29:30.251]             length <- base::length
[01:29:30.251]             list <- base::list
[01:29:30.251]             seq.int <- base::seq.int
[01:29:30.251]             signalCondition <- base::signalCondition
[01:29:30.251]             sys.calls <- base::sys.calls
[01:29:30.251]             `[[` <- base::`[[`
[01:29:30.251]             `+` <- base::`+`
[01:29:30.251]             `<<-` <- base::`<<-`
[01:29:30.251]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:30.251]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:30.251]                   3L)]
[01:29:30.251]             }
[01:29:30.251]             function(cond) {
[01:29:30.251]                 is_error <- inherits(cond, "error")
[01:29:30.251]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:30.251]                   NULL)
[01:29:30.251]                 if (is_error) {
[01:29:30.251]                   sessionInformation <- function() {
[01:29:30.251]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:30.251]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:30.251]                       search = base::search(), system = base::Sys.info())
[01:29:30.251]                   }
[01:29:30.251]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.251]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:30.251]                     cond$call), session = sessionInformation(), 
[01:29:30.251]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:30.251]                   signalCondition(cond)
[01:29:30.251]                 }
[01:29:30.251]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:30.251]                 "immediateCondition"))) {
[01:29:30.251]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:30.251]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.251]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:30.251]                   if (TRUE && !signal) {
[01:29:30.251]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.251]                     {
[01:29:30.251]                       inherits <- base::inherits
[01:29:30.251]                       invokeRestart <- base::invokeRestart
[01:29:30.251]                       is.null <- base::is.null
[01:29:30.251]                       muffled <- FALSE
[01:29:30.251]                       if (inherits(cond, "message")) {
[01:29:30.251]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.251]                         if (muffled) 
[01:29:30.251]                           invokeRestart("muffleMessage")
[01:29:30.251]                       }
[01:29:30.251]                       else if (inherits(cond, "warning")) {
[01:29:30.251]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.251]                         if (muffled) 
[01:29:30.251]                           invokeRestart("muffleWarning")
[01:29:30.251]                       }
[01:29:30.251]                       else if (inherits(cond, "condition")) {
[01:29:30.251]                         if (!is.null(pattern)) {
[01:29:30.251]                           computeRestarts <- base::computeRestarts
[01:29:30.251]                           grepl <- base::grepl
[01:29:30.251]                           restarts <- computeRestarts(cond)
[01:29:30.251]                           for (restart in restarts) {
[01:29:30.251]                             name <- restart$name
[01:29:30.251]                             if (is.null(name)) 
[01:29:30.251]                               next
[01:29:30.251]                             if (!grepl(pattern, name)) 
[01:29:30.251]                               next
[01:29:30.251]                             invokeRestart(restart)
[01:29:30.251]                             muffled <- TRUE
[01:29:30.251]                             break
[01:29:30.251]                           }
[01:29:30.251]                         }
[01:29:30.251]                       }
[01:29:30.251]                       invisible(muffled)
[01:29:30.251]                     }
[01:29:30.251]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.251]                   }
[01:29:30.251]                 }
[01:29:30.251]                 else {
[01:29:30.251]                   if (TRUE) {
[01:29:30.251]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.251]                     {
[01:29:30.251]                       inherits <- base::inherits
[01:29:30.251]                       invokeRestart <- base::invokeRestart
[01:29:30.251]                       is.null <- base::is.null
[01:29:30.251]                       muffled <- FALSE
[01:29:30.251]                       if (inherits(cond, "message")) {
[01:29:30.251]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.251]                         if (muffled) 
[01:29:30.251]                           invokeRestart("muffleMessage")
[01:29:30.251]                       }
[01:29:30.251]                       else if (inherits(cond, "warning")) {
[01:29:30.251]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.251]                         if (muffled) 
[01:29:30.251]                           invokeRestart("muffleWarning")
[01:29:30.251]                       }
[01:29:30.251]                       else if (inherits(cond, "condition")) {
[01:29:30.251]                         if (!is.null(pattern)) {
[01:29:30.251]                           computeRestarts <- base::computeRestarts
[01:29:30.251]                           grepl <- base::grepl
[01:29:30.251]                           restarts <- computeRestarts(cond)
[01:29:30.251]                           for (restart in restarts) {
[01:29:30.251]                             name <- restart$name
[01:29:30.251]                             if (is.null(name)) 
[01:29:30.251]                               next
[01:29:30.251]                             if (!grepl(pattern, name)) 
[01:29:30.251]                               next
[01:29:30.251]                             invokeRestart(restart)
[01:29:30.251]                             muffled <- TRUE
[01:29:30.251]                             break
[01:29:30.251]                           }
[01:29:30.251]                         }
[01:29:30.251]                       }
[01:29:30.251]                       invisible(muffled)
[01:29:30.251]                     }
[01:29:30.251]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.251]                   }
[01:29:30.251]                 }
[01:29:30.251]             }
[01:29:30.251]         }))
[01:29:30.251]     }, error = function(ex) {
[01:29:30.251]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:30.251]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.251]                 ...future.rng), started = ...future.startTime, 
[01:29:30.251]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:30.251]             version = "1.8"), class = "FutureResult")
[01:29:30.251]     }, finally = {
[01:29:30.251]         if (!identical(...future.workdir, getwd())) 
[01:29:30.251]             setwd(...future.workdir)
[01:29:30.251]         {
[01:29:30.251]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:30.251]                 ...future.oldOptions$nwarnings <- NULL
[01:29:30.251]             }
[01:29:30.251]             base::options(...future.oldOptions)
[01:29:30.251]             if (.Platform$OS.type == "windows") {
[01:29:30.251]                 old_names <- names(...future.oldEnvVars)
[01:29:30.251]                 envs <- base::Sys.getenv()
[01:29:30.251]                 names <- names(envs)
[01:29:30.251]                 common <- intersect(names, old_names)
[01:29:30.251]                 added <- setdiff(names, old_names)
[01:29:30.251]                 removed <- setdiff(old_names, names)
[01:29:30.251]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:30.251]                   envs[common]]
[01:29:30.251]                 NAMES <- toupper(changed)
[01:29:30.251]                 args <- list()
[01:29:30.251]                 for (kk in seq_along(NAMES)) {
[01:29:30.251]                   name <- changed[[kk]]
[01:29:30.251]                   NAME <- NAMES[[kk]]
[01:29:30.251]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.251]                     next
[01:29:30.251]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.251]                 }
[01:29:30.251]                 NAMES <- toupper(added)
[01:29:30.251]                 for (kk in seq_along(NAMES)) {
[01:29:30.251]                   name <- added[[kk]]
[01:29:30.251]                   NAME <- NAMES[[kk]]
[01:29:30.251]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.251]                     next
[01:29:30.251]                   args[[name]] <- ""
[01:29:30.251]                 }
[01:29:30.251]                 NAMES <- toupper(removed)
[01:29:30.251]                 for (kk in seq_along(NAMES)) {
[01:29:30.251]                   name <- removed[[kk]]
[01:29:30.251]                   NAME <- NAMES[[kk]]
[01:29:30.251]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.251]                     next
[01:29:30.251]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.251]                 }
[01:29:30.251]                 if (length(args) > 0) 
[01:29:30.251]                   base::do.call(base::Sys.setenv, args = args)
[01:29:30.251]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:30.251]             }
[01:29:30.251]             else {
[01:29:30.251]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:30.251]             }
[01:29:30.251]             {
[01:29:30.251]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:30.251]                   0L) {
[01:29:30.251]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:30.251]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:30.251]                   base::options(opts)
[01:29:30.251]                 }
[01:29:30.251]                 {
[01:29:30.251]                   {
[01:29:30.251]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:30.251]                     NULL
[01:29:30.251]                   }
[01:29:30.251]                   options(future.plan = NULL)
[01:29:30.251]                   if (is.na(NA_character_)) 
[01:29:30.251]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.251]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:30.251]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:30.251]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:30.251]                     envir = parent.frame()) 
[01:29:30.251]                   {
[01:29:30.251]                     if (is.function(workers)) 
[01:29:30.251]                       workers <- workers()
[01:29:30.251]                     workers <- structure(as.integer(workers), 
[01:29:30.251]                       class = class(workers))
[01:29:30.251]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:30.251]                       workers >= 1)
[01:29:30.251]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:30.251]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:30.251]                     }
[01:29:30.251]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:30.251]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:30.251]                       envir = envir)
[01:29:30.251]                     if (!future$lazy) 
[01:29:30.251]                       future <- run(future)
[01:29:30.251]                     invisible(future)
[01:29:30.251]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:30.251]                 }
[01:29:30.251]             }
[01:29:30.251]         }
[01:29:30.251]     })
[01:29:30.251]     if (TRUE) {
[01:29:30.251]         base::sink(type = "output", split = FALSE)
[01:29:30.251]         if (TRUE) {
[01:29:30.251]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:30.251]         }
[01:29:30.251]         else {
[01:29:30.251]             ...future.result["stdout"] <- base::list(NULL)
[01:29:30.251]         }
[01:29:30.251]         base::close(...future.stdout)
[01:29:30.251]         ...future.stdout <- NULL
[01:29:30.251]     }
[01:29:30.251]     ...future.result$conditions <- ...future.conditions
[01:29:30.251]     ...future.result$finished <- base::Sys.time()
[01:29:30.251]     ...future.result
[01:29:30.251] }
[01:29:30.257] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:30.257] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:30.257] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:30.257] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:30.258] MultisessionFuture started
[01:29:30.258] - Launch lazy future ... done
[01:29:30.259] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_3-973560'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96dd906f8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[01:29:30.275] receiveMessageFromWorker() for ClusterFuture ...
[01:29:30.275] - Validating connection of MultisessionFuture
[01:29:30.276] - received message: FutureResult
[01:29:30.276] - Received FutureResult
[01:29:30.276] - Erased future from FutureRegistry
[01:29:30.276] result() for ClusterFuture ...
[01:29:30.276] - result already collected: FutureResult
[01:29:30.277] result() for ClusterFuture ... done
[01:29:30.277] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.277] getGlobalsAndPackages() ...
[01:29:30.277] Searching for globals...
[01:29:30.278] - globals found: [3] '{', 'sample', 'x'
[01:29:30.279] Searching for globals ... DONE
[01:29:30.279] Resolving globals: FALSE
[01:29:30.279] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:30.280] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:30.280] - globals: [1] 'x'
[01:29:30.280] 
[01:29:30.281] getGlobalsAndPackages() ... DONE
[01:29:30.281] run() for 'Future' ...
[01:29:30.281] - state: 'created'
[01:29:30.281] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:30.298] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.299] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:30.299]   - Field: 'node'
[01:29:30.299]   - Field: 'label'
[01:29:30.299]   - Field: 'local'
[01:29:30.299]   - Field: 'owner'
[01:29:30.300]   - Field: 'envir'
[01:29:30.300]   - Field: 'workers'
[01:29:30.300]   - Field: 'packages'
[01:29:30.300]   - Field: 'gc'
[01:29:30.300]   - Field: 'conditions'
[01:29:30.300]   - Field: 'persistent'
[01:29:30.301]   - Field: 'expr'
[01:29:30.301]   - Field: 'uuid'
[01:29:30.301]   - Field: 'seed'
[01:29:30.301]   - Field: 'version'
[01:29:30.301]   - Field: 'result'
[01:29:30.302]   - Field: 'asynchronous'
[01:29:30.302]   - Field: 'calls'
[01:29:30.302]   - Field: 'globals'
[01:29:30.302]   - Field: 'stdout'
[01:29:30.302]   - Field: 'earlySignal'
[01:29:30.302]   - Field: 'lazy'
[01:29:30.303]   - Field: 'state'
[01:29:30.303] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:30.303] - Launch lazy future ...
[01:29:30.303] Packages needed by the future expression (n = 0): <none>
[01:29:30.304] Packages needed by future strategies (n = 0): <none>
[01:29:30.304] {
[01:29:30.304]     {
[01:29:30.304]         {
[01:29:30.304]             ...future.startTime <- base::Sys.time()
[01:29:30.304]             {
[01:29:30.304]                 {
[01:29:30.304]                   {
[01:29:30.304]                     {
[01:29:30.304]                       base::local({
[01:29:30.304]                         has_future <- base::requireNamespace("future", 
[01:29:30.304]                           quietly = TRUE)
[01:29:30.304]                         if (has_future) {
[01:29:30.304]                           ns <- base::getNamespace("future")
[01:29:30.304]                           version <- ns[[".package"]][["version"]]
[01:29:30.304]                           if (is.null(version)) 
[01:29:30.304]                             version <- utils::packageVersion("future")
[01:29:30.304]                         }
[01:29:30.304]                         else {
[01:29:30.304]                           version <- NULL
[01:29:30.304]                         }
[01:29:30.304]                         if (!has_future || version < "1.8.0") {
[01:29:30.304]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:30.304]                             "", base::R.version$version.string), 
[01:29:30.304]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:30.304]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:30.304]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:30.304]                               "release", "version")], collapse = " "), 
[01:29:30.304]                             hostname = base::Sys.info()[["nodename"]])
[01:29:30.304]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:30.304]                             info)
[01:29:30.304]                           info <- base::paste(info, collapse = "; ")
[01:29:30.304]                           if (!has_future) {
[01:29:30.304]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:30.304]                               info)
[01:29:30.304]                           }
[01:29:30.304]                           else {
[01:29:30.304]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:30.304]                               info, version)
[01:29:30.304]                           }
[01:29:30.304]                           base::stop(msg)
[01:29:30.304]                         }
[01:29:30.304]                       })
[01:29:30.304]                     }
[01:29:30.304]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:30.304]                     base::options(mc.cores = 1L)
[01:29:30.304]                   }
[01:29:30.304]                   options(future.plan = NULL)
[01:29:30.304]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.304]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:30.304]                 }
[01:29:30.304]                 ...future.workdir <- getwd()
[01:29:30.304]             }
[01:29:30.304]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:30.304]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:30.304]         }
[01:29:30.304]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:30.304]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:30.304]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:30.304]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:30.304]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:30.304]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:30.304]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:30.304]             base::names(...future.oldOptions))
[01:29:30.304]     }
[01:29:30.304]     if (FALSE) {
[01:29:30.304]     }
[01:29:30.304]     else {
[01:29:30.304]         if (TRUE) {
[01:29:30.304]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:30.304]                 open = "w")
[01:29:30.304]         }
[01:29:30.304]         else {
[01:29:30.304]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:30.304]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:30.304]         }
[01:29:30.304]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:30.304]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:30.304]             base::sink(type = "output", split = FALSE)
[01:29:30.304]             base::close(...future.stdout)
[01:29:30.304]         }, add = TRUE)
[01:29:30.304]     }
[01:29:30.304]     ...future.frame <- base::sys.nframe()
[01:29:30.304]     ...future.conditions <- base::list()
[01:29:30.304]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:30.304]     if (FALSE) {
[01:29:30.304]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:30.304]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:30.304]     }
[01:29:30.304]     ...future.result <- base::tryCatch({
[01:29:30.304]         base::withCallingHandlers({
[01:29:30.304]             ...future.value <- base::withVisible(base::local({
[01:29:30.304]                 ...future.makeSendCondition <- base::local({
[01:29:30.304]                   sendCondition <- NULL
[01:29:30.304]                   function(frame = 1L) {
[01:29:30.304]                     if (is.function(sendCondition)) 
[01:29:30.304]                       return(sendCondition)
[01:29:30.304]                     ns <- getNamespace("parallel")
[01:29:30.304]                     if (exists("sendData", mode = "function", 
[01:29:30.304]                       envir = ns)) {
[01:29:30.304]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:30.304]                         envir = ns)
[01:29:30.304]                       envir <- sys.frame(frame)
[01:29:30.304]                       master <- NULL
[01:29:30.304]                       while (!identical(envir, .GlobalEnv) && 
[01:29:30.304]                         !identical(envir, emptyenv())) {
[01:29:30.304]                         if (exists("master", mode = "list", envir = envir, 
[01:29:30.304]                           inherits = FALSE)) {
[01:29:30.304]                           master <- get("master", mode = "list", 
[01:29:30.304]                             envir = envir, inherits = FALSE)
[01:29:30.304]                           if (inherits(master, c("SOCKnode", 
[01:29:30.304]                             "SOCK0node"))) {
[01:29:30.304]                             sendCondition <<- function(cond) {
[01:29:30.304]                               data <- list(type = "VALUE", value = cond, 
[01:29:30.304]                                 success = TRUE)
[01:29:30.304]                               parallel_sendData(master, data)
[01:29:30.304]                             }
[01:29:30.304]                             return(sendCondition)
[01:29:30.304]                           }
[01:29:30.304]                         }
[01:29:30.304]                         frame <- frame + 1L
[01:29:30.304]                         envir <- sys.frame(frame)
[01:29:30.304]                       }
[01:29:30.304]                     }
[01:29:30.304]                     sendCondition <<- function(cond) NULL
[01:29:30.304]                   }
[01:29:30.304]                 })
[01:29:30.304]                 withCallingHandlers({
[01:29:30.304]                   {
[01:29:30.304]                     sample(x, size = 1L)
[01:29:30.304]                   }
[01:29:30.304]                 }, immediateCondition = function(cond) {
[01:29:30.304]                   sendCondition <- ...future.makeSendCondition()
[01:29:30.304]                   sendCondition(cond)
[01:29:30.304]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.304]                   {
[01:29:30.304]                     inherits <- base::inherits
[01:29:30.304]                     invokeRestart <- base::invokeRestart
[01:29:30.304]                     is.null <- base::is.null
[01:29:30.304]                     muffled <- FALSE
[01:29:30.304]                     if (inherits(cond, "message")) {
[01:29:30.304]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:30.304]                       if (muffled) 
[01:29:30.304]                         invokeRestart("muffleMessage")
[01:29:30.304]                     }
[01:29:30.304]                     else if (inherits(cond, "warning")) {
[01:29:30.304]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:30.304]                       if (muffled) 
[01:29:30.304]                         invokeRestart("muffleWarning")
[01:29:30.304]                     }
[01:29:30.304]                     else if (inherits(cond, "condition")) {
[01:29:30.304]                       if (!is.null(pattern)) {
[01:29:30.304]                         computeRestarts <- base::computeRestarts
[01:29:30.304]                         grepl <- base::grepl
[01:29:30.304]                         restarts <- computeRestarts(cond)
[01:29:30.304]                         for (restart in restarts) {
[01:29:30.304]                           name <- restart$name
[01:29:30.304]                           if (is.null(name)) 
[01:29:30.304]                             next
[01:29:30.304]                           if (!grepl(pattern, name)) 
[01:29:30.304]                             next
[01:29:30.304]                           invokeRestart(restart)
[01:29:30.304]                           muffled <- TRUE
[01:29:30.304]                           break
[01:29:30.304]                         }
[01:29:30.304]                       }
[01:29:30.304]                     }
[01:29:30.304]                     invisible(muffled)
[01:29:30.304]                   }
[01:29:30.304]                   muffleCondition(cond)
[01:29:30.304]                 })
[01:29:30.304]             }))
[01:29:30.304]             future::FutureResult(value = ...future.value$value, 
[01:29:30.304]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.304]                   ...future.rng), globalenv = if (FALSE) 
[01:29:30.304]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:30.304]                     ...future.globalenv.names))
[01:29:30.304]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:30.304]         }, condition = base::local({
[01:29:30.304]             c <- base::c
[01:29:30.304]             inherits <- base::inherits
[01:29:30.304]             invokeRestart <- base::invokeRestart
[01:29:30.304]             length <- base::length
[01:29:30.304]             list <- base::list
[01:29:30.304]             seq.int <- base::seq.int
[01:29:30.304]             signalCondition <- base::signalCondition
[01:29:30.304]             sys.calls <- base::sys.calls
[01:29:30.304]             `[[` <- base::`[[`
[01:29:30.304]             `+` <- base::`+`
[01:29:30.304]             `<<-` <- base::`<<-`
[01:29:30.304]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:30.304]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:30.304]                   3L)]
[01:29:30.304]             }
[01:29:30.304]             function(cond) {
[01:29:30.304]                 is_error <- inherits(cond, "error")
[01:29:30.304]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:30.304]                   NULL)
[01:29:30.304]                 if (is_error) {
[01:29:30.304]                   sessionInformation <- function() {
[01:29:30.304]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:30.304]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:30.304]                       search = base::search(), system = base::Sys.info())
[01:29:30.304]                   }
[01:29:30.304]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.304]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:30.304]                     cond$call), session = sessionInformation(), 
[01:29:30.304]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:30.304]                   signalCondition(cond)
[01:29:30.304]                 }
[01:29:30.304]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:30.304]                 "immediateCondition"))) {
[01:29:30.304]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:30.304]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.304]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:30.304]                   if (TRUE && !signal) {
[01:29:30.304]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.304]                     {
[01:29:30.304]                       inherits <- base::inherits
[01:29:30.304]                       invokeRestart <- base::invokeRestart
[01:29:30.304]                       is.null <- base::is.null
[01:29:30.304]                       muffled <- FALSE
[01:29:30.304]                       if (inherits(cond, "message")) {
[01:29:30.304]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.304]                         if (muffled) 
[01:29:30.304]                           invokeRestart("muffleMessage")
[01:29:30.304]                       }
[01:29:30.304]                       else if (inherits(cond, "warning")) {
[01:29:30.304]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.304]                         if (muffled) 
[01:29:30.304]                           invokeRestart("muffleWarning")
[01:29:30.304]                       }
[01:29:30.304]                       else if (inherits(cond, "condition")) {
[01:29:30.304]                         if (!is.null(pattern)) {
[01:29:30.304]                           computeRestarts <- base::computeRestarts
[01:29:30.304]                           grepl <- base::grepl
[01:29:30.304]                           restarts <- computeRestarts(cond)
[01:29:30.304]                           for (restart in restarts) {
[01:29:30.304]                             name <- restart$name
[01:29:30.304]                             if (is.null(name)) 
[01:29:30.304]                               next
[01:29:30.304]                             if (!grepl(pattern, name)) 
[01:29:30.304]                               next
[01:29:30.304]                             invokeRestart(restart)
[01:29:30.304]                             muffled <- TRUE
[01:29:30.304]                             break
[01:29:30.304]                           }
[01:29:30.304]                         }
[01:29:30.304]                       }
[01:29:30.304]                       invisible(muffled)
[01:29:30.304]                     }
[01:29:30.304]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.304]                   }
[01:29:30.304]                 }
[01:29:30.304]                 else {
[01:29:30.304]                   if (TRUE) {
[01:29:30.304]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.304]                     {
[01:29:30.304]                       inherits <- base::inherits
[01:29:30.304]                       invokeRestart <- base::invokeRestart
[01:29:30.304]                       is.null <- base::is.null
[01:29:30.304]                       muffled <- FALSE
[01:29:30.304]                       if (inherits(cond, "message")) {
[01:29:30.304]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.304]                         if (muffled) 
[01:29:30.304]                           invokeRestart("muffleMessage")
[01:29:30.304]                       }
[01:29:30.304]                       else if (inherits(cond, "warning")) {
[01:29:30.304]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.304]                         if (muffled) 
[01:29:30.304]                           invokeRestart("muffleWarning")
[01:29:30.304]                       }
[01:29:30.304]                       else if (inherits(cond, "condition")) {
[01:29:30.304]                         if (!is.null(pattern)) {
[01:29:30.304]                           computeRestarts <- base::computeRestarts
[01:29:30.304]                           grepl <- base::grepl
[01:29:30.304]                           restarts <- computeRestarts(cond)
[01:29:30.304]                           for (restart in restarts) {
[01:29:30.304]                             name <- restart$name
[01:29:30.304]                             if (is.null(name)) 
[01:29:30.304]                               next
[01:29:30.304]                             if (!grepl(pattern, name)) 
[01:29:30.304]                               next
[01:29:30.304]                             invokeRestart(restart)
[01:29:30.304]                             muffled <- TRUE
[01:29:30.304]                             break
[01:29:30.304]                           }
[01:29:30.304]                         }
[01:29:30.304]                       }
[01:29:30.304]                       invisible(muffled)
[01:29:30.304]                     }
[01:29:30.304]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.304]                   }
[01:29:30.304]                 }
[01:29:30.304]             }
[01:29:30.304]         }))
[01:29:30.304]     }, error = function(ex) {
[01:29:30.304]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:30.304]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.304]                 ...future.rng), started = ...future.startTime, 
[01:29:30.304]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:30.304]             version = "1.8"), class = "FutureResult")
[01:29:30.304]     }, finally = {
[01:29:30.304]         if (!identical(...future.workdir, getwd())) 
[01:29:30.304]             setwd(...future.workdir)
[01:29:30.304]         {
[01:29:30.304]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:30.304]                 ...future.oldOptions$nwarnings <- NULL
[01:29:30.304]             }
[01:29:30.304]             base::options(...future.oldOptions)
[01:29:30.304]             if (.Platform$OS.type == "windows") {
[01:29:30.304]                 old_names <- names(...future.oldEnvVars)
[01:29:30.304]                 envs <- base::Sys.getenv()
[01:29:30.304]                 names <- names(envs)
[01:29:30.304]                 common <- intersect(names, old_names)
[01:29:30.304]                 added <- setdiff(names, old_names)
[01:29:30.304]                 removed <- setdiff(old_names, names)
[01:29:30.304]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:30.304]                   envs[common]]
[01:29:30.304]                 NAMES <- toupper(changed)
[01:29:30.304]                 args <- list()
[01:29:30.304]                 for (kk in seq_along(NAMES)) {
[01:29:30.304]                   name <- changed[[kk]]
[01:29:30.304]                   NAME <- NAMES[[kk]]
[01:29:30.304]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.304]                     next
[01:29:30.304]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.304]                 }
[01:29:30.304]                 NAMES <- toupper(added)
[01:29:30.304]                 for (kk in seq_along(NAMES)) {
[01:29:30.304]                   name <- added[[kk]]
[01:29:30.304]                   NAME <- NAMES[[kk]]
[01:29:30.304]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.304]                     next
[01:29:30.304]                   args[[name]] <- ""
[01:29:30.304]                 }
[01:29:30.304]                 NAMES <- toupper(removed)
[01:29:30.304]                 for (kk in seq_along(NAMES)) {
[01:29:30.304]                   name <- removed[[kk]]
[01:29:30.304]                   NAME <- NAMES[[kk]]
[01:29:30.304]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.304]                     next
[01:29:30.304]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.304]                 }
[01:29:30.304]                 if (length(args) > 0) 
[01:29:30.304]                   base::do.call(base::Sys.setenv, args = args)
[01:29:30.304]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:30.304]             }
[01:29:30.304]             else {
[01:29:30.304]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:30.304]             }
[01:29:30.304]             {
[01:29:30.304]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:30.304]                   0L) {
[01:29:30.304]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:30.304]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:30.304]                   base::options(opts)
[01:29:30.304]                 }
[01:29:30.304]                 {
[01:29:30.304]                   {
[01:29:30.304]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:30.304]                     NULL
[01:29:30.304]                   }
[01:29:30.304]                   options(future.plan = NULL)
[01:29:30.304]                   if (is.na(NA_character_)) 
[01:29:30.304]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.304]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:30.304]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:30.304]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:30.304]                     envir = parent.frame()) 
[01:29:30.304]                   {
[01:29:30.304]                     if (is.function(workers)) 
[01:29:30.304]                       workers <- workers()
[01:29:30.304]                     workers <- structure(as.integer(workers), 
[01:29:30.304]                       class = class(workers))
[01:29:30.304]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:30.304]                       workers >= 1)
[01:29:30.304]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:30.304]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:30.304]                     }
[01:29:30.304]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:30.304]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:30.304]                       envir = envir)
[01:29:30.304]                     if (!future$lazy) 
[01:29:30.304]                       future <- run(future)
[01:29:30.304]                     invisible(future)
[01:29:30.304]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:30.304]                 }
[01:29:30.304]             }
[01:29:30.304]         }
[01:29:30.304]     })
[01:29:30.304]     if (TRUE) {
[01:29:30.304]         base::sink(type = "output", split = FALSE)
[01:29:30.304]         if (TRUE) {
[01:29:30.304]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:30.304]         }
[01:29:30.304]         else {
[01:29:30.304]             ...future.result["stdout"] <- base::list(NULL)
[01:29:30.304]         }
[01:29:30.304]         base::close(...future.stdout)
[01:29:30.304]         ...future.stdout <- NULL
[01:29:30.304]     }
[01:29:30.304]     ...future.result$conditions <- ...future.conditions
[01:29:30.304]     ...future.result$finished <- base::Sys.time()
[01:29:30.304]     ...future.result
[01:29:30.304] }
[01:29:30.309] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:30.310] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:30.310] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:30.310] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:30.311] MultisessionFuture started
[01:29:30.311] - Launch lazy future ... done
[01:29:30.311] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_4-109777'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96dd906f8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[01:29:30.326] receiveMessageFromWorker() for ClusterFuture ...
[01:29:30.327] - Validating connection of MultisessionFuture
[01:29:30.327] - received message: FutureResult
[01:29:30.327] - Received FutureResult
[01:29:30.327] - Erased future from FutureRegistry
[01:29:30.328] result() for ClusterFuture ...
[01:29:30.328] - result already collected: FutureResult
[01:29:30.328] result() for ClusterFuture ... done
[01:29:30.328] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.328] resolve() on list ...
[01:29:30.329]  recursive: 0
[01:29:30.329]  length: 4
[01:29:30.329] 
[01:29:30.329] Future #1
[01:29:30.329] result() for ClusterFuture ...
[01:29:30.329] - result already collected: FutureResult
[01:29:30.330] result() for ClusterFuture ... done
[01:29:30.330] result() for ClusterFuture ...
[01:29:30.330] - result already collected: FutureResult
[01:29:30.330] result() for ClusterFuture ... done
[01:29:30.330] signalConditionsASAP(MultisessionFuture, pos=1) ...
[01:29:30.331] - nx: 4
[01:29:30.331] - relay: TRUE
[01:29:30.331] - stdout: TRUE
[01:29:30.331] - signal: TRUE
[01:29:30.331] - resignal: FALSE
[01:29:30.332] - force: TRUE
[01:29:30.332] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:30.332] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:30.332]  - until=1
[01:29:30.332]  - relaying element #1
[01:29:30.332] result() for ClusterFuture ...
[01:29:30.333] - result already collected: FutureResult
[01:29:30.333] result() for ClusterFuture ... done
[01:29:30.333] result() for ClusterFuture ...
[01:29:30.333] - result already collected: FutureResult
[01:29:30.333] result() for ClusterFuture ... done
[01:29:30.333] result() for ClusterFuture ...
[01:29:30.334] - result already collected: FutureResult
[01:29:30.334] result() for ClusterFuture ... done
[01:29:30.334] result() for ClusterFuture ...
[01:29:30.334] - result already collected: FutureResult
[01:29:30.334] result() for ClusterFuture ... done
[01:29:30.334] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:30.335] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:30.335] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[01:29:30.335]  length: 3 (resolved future 1)
[01:29:30.335] Future #2
[01:29:30.335] result() for ClusterFuture ...
[01:29:30.335] - result already collected: FutureResult
[01:29:30.336] result() for ClusterFuture ... done
[01:29:30.336] result() for ClusterFuture ...
[01:29:30.336] - result already collected: FutureResult
[01:29:30.336] result() for ClusterFuture ... done
[01:29:30.336] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:29:30.337] - nx: 4
[01:29:30.337] - relay: TRUE
[01:29:30.337] - stdout: TRUE
[01:29:30.337] - signal: TRUE
[01:29:30.337] - resignal: FALSE
[01:29:30.337] - force: TRUE
[01:29:30.337] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:30.338] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:30.338]  - until=2
[01:29:30.338]  - relaying element #2
[01:29:30.338] result() for ClusterFuture ...
[01:29:30.338] - result already collected: FutureResult
[01:29:30.339] result() for ClusterFuture ... done
[01:29:30.339] result() for ClusterFuture ...
[01:29:30.339] - result already collected: FutureResult
[01:29:30.339] result() for ClusterFuture ... done
[01:29:30.339] result() for ClusterFuture ...
[01:29:30.340] - result already collected: FutureResult
[01:29:30.340] result() for ClusterFuture ... done
[01:29:30.340] result() for ClusterFuture ...
[01:29:30.340] - result already collected: FutureResult
[01:29:30.340] result() for ClusterFuture ... done
[01:29:30.341] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:30.341] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:30.341] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:29:30.341]  length: 2 (resolved future 2)
[01:29:30.341] Future #3
[01:29:30.341] result() for ClusterFuture ...
[01:29:30.342] - result already collected: FutureResult
[01:29:30.342] result() for ClusterFuture ... done
[01:29:30.342] result() for ClusterFuture ...
[01:29:30.342] - result already collected: FutureResult
[01:29:30.342] result() for ClusterFuture ... done
[01:29:30.342] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:29:30.343] - nx: 4
[01:29:30.343] - relay: TRUE
[01:29:30.343] - stdout: TRUE
[01:29:30.343] - signal: TRUE
[01:29:30.343] - resignal: FALSE
[01:29:30.343] - force: TRUE
[01:29:30.344] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:30.344] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:30.344]  - until=3
[01:29:30.344]  - relaying element #3
[01:29:30.344] result() for ClusterFuture ...
[01:29:30.345] - result already collected: FutureResult
[01:29:30.345] result() for ClusterFuture ... done
[01:29:30.345] result() for ClusterFuture ...
[01:29:30.345] - result already collected: FutureResult
[01:29:30.345] result() for ClusterFuture ... done
[01:29:30.345] result() for ClusterFuture ...
[01:29:30.346] - result already collected: FutureResult
[01:29:30.346] result() for ClusterFuture ... done
[01:29:30.346] result() for ClusterFuture ...
[01:29:30.346] - result already collected: FutureResult
[01:29:30.346] result() for ClusterFuture ... done
[01:29:30.347] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:30.347] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:30.347] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:29:30.347]  length: 1 (resolved future 3)
[01:29:30.348] Future #4
[01:29:30.348] result() for ClusterFuture ...
[01:29:30.348] - result already collected: FutureResult
[01:29:30.348] result() for ClusterFuture ... done
[01:29:30.348] result() for ClusterFuture ...
[01:29:30.349] - result already collected: FutureResult
[01:29:30.349] result() for ClusterFuture ... done
[01:29:30.349] signalConditionsASAP(MultisessionFuture, pos=4) ...
[01:29:30.349] - nx: 4
[01:29:30.350] - relay: TRUE
[01:29:30.350] - stdout: TRUE
[01:29:30.350] - signal: TRUE
[01:29:30.350] - resignal: FALSE
[01:29:30.350] - force: TRUE
[01:29:30.350] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:30.351] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:30.351]  - until=4
[01:29:30.351]  - relaying element #4
[01:29:30.351] result() for ClusterFuture ...
[01:29:30.351] - result already collected: FutureResult
[01:29:30.352] result() for ClusterFuture ... done
[01:29:30.352] result() for ClusterFuture ...
[01:29:30.352] - result already collected: FutureResult
[01:29:30.352] result() for ClusterFuture ... done
[01:29:30.352] result() for ClusterFuture ...
[01:29:30.352] - result already collected: FutureResult
[01:29:30.353] result() for ClusterFuture ... done
[01:29:30.353] result() for ClusterFuture ...
[01:29:30.353] - result already collected: FutureResult
[01:29:30.353] result() for ClusterFuture ... done
[01:29:30.353] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:30.353] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:30.354] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[01:29:30.354]  length: 0 (resolved future 4)
[01:29:30.354] Relaying remaining futures
[01:29:30.354] signalConditionsASAP(NULL, pos=0) ...
[01:29:30.354] - nx: 4
[01:29:30.354] - relay: TRUE
[01:29:30.355] - stdout: TRUE
[01:29:30.355] - signal: TRUE
[01:29:30.355] - resignal: FALSE
[01:29:30.355] - force: TRUE
[01:29:30.355] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:30.355] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[01:29:30.356] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:30.356] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:30.356] signalConditionsASAP(NULL, pos=0) ... done
[01:29:30.356] resolve() on list ... DONE
[01:29:30.356] result() for ClusterFuture ...
[01:29:30.357] - result already collected: FutureResult
[01:29:30.357] result() for ClusterFuture ... done
[01:29:30.357] result() for ClusterFuture ...
[01:29:30.357] - result already collected: FutureResult
[01:29:30.357] result() for ClusterFuture ... done
[01:29:30.358] result() for ClusterFuture ...
[01:29:30.358] - result already collected: FutureResult
[01:29:30.358] result() for ClusterFuture ... done
[01:29:30.358] result() for ClusterFuture ...
[01:29:30.359] - result already collected: FutureResult
[01:29:30.359] result() for ClusterFuture ... done
[01:29:30.359] result() for ClusterFuture ...
[01:29:30.359] - result already collected: FutureResult
[01:29:30.359] result() for ClusterFuture ... done
[01:29:30.359] result() for ClusterFuture ...
[01:29:30.360] - result already collected: FutureResult
[01:29:30.360] result() for ClusterFuture ... done
[01:29:30.360] result() for ClusterFuture ...
[01:29:30.360] - result already collected: FutureResult
[01:29:30.360] result() for ClusterFuture ... done
[01:29:30.361] result() for ClusterFuture ...
[01:29:30.361] - result already collected: FutureResult
[01:29:30.361] result() for ClusterFuture ... done
[[1]]
[1] 3

[[2]]
[1] 2

[[3]]
[1] 2

[[4]]
[1] 3

[01:29:30.361] getGlobalsAndPackages() ...
[01:29:30.362] Searching for globals...
[01:29:30.365] - globals found: [3] '{', 'sample', 'x'
[01:29:30.365] Searching for globals ... DONE
[01:29:30.366] Resolving globals: FALSE
[01:29:30.367] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:30.368] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:30.368] - globals: [1] 'x'
[01:29:30.369] 
[01:29:30.369] getGlobalsAndPackages() ... DONE
[01:29:30.370] run() for 'Future' ...
[01:29:30.370] - state: 'created'
[01:29:30.371] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:30.390] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.391] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:30.391]   - Field: 'node'
[01:29:30.391]   - Field: 'label'
[01:29:30.391]   - Field: 'local'
[01:29:30.392]   - Field: 'owner'
[01:29:30.392]   - Field: 'envir'
[01:29:30.392]   - Field: 'workers'
[01:29:30.392]   - Field: 'packages'
[01:29:30.392]   - Field: 'gc'
[01:29:30.393]   - Field: 'conditions'
[01:29:30.393]   - Field: 'persistent'
[01:29:30.393]   - Field: 'expr'
[01:29:30.393]   - Field: 'uuid'
[01:29:30.393]   - Field: 'seed'
[01:29:30.394]   - Field: 'version'
[01:29:30.394]   - Field: 'result'
[01:29:30.394]   - Field: 'asynchronous'
[01:29:30.394]   - Field: 'calls'
[01:29:30.395]   - Field: 'globals'
[01:29:30.395]   - Field: 'stdout'
[01:29:30.395]   - Field: 'earlySignal'
[01:29:30.395]   - Field: 'lazy'
[01:29:30.395]   - Field: 'state'
[01:29:30.395] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:30.396] - Launch lazy future ...
[01:29:30.396] Packages needed by the future expression (n = 0): <none>
[01:29:30.396] Packages needed by future strategies (n = 0): <none>
[01:29:30.397] {
[01:29:30.397]     {
[01:29:30.397]         {
[01:29:30.397]             ...future.startTime <- base::Sys.time()
[01:29:30.397]             {
[01:29:30.397]                 {
[01:29:30.397]                   {
[01:29:30.397]                     {
[01:29:30.397]                       base::local({
[01:29:30.397]                         has_future <- base::requireNamespace("future", 
[01:29:30.397]                           quietly = TRUE)
[01:29:30.397]                         if (has_future) {
[01:29:30.397]                           ns <- base::getNamespace("future")
[01:29:30.397]                           version <- ns[[".package"]][["version"]]
[01:29:30.397]                           if (is.null(version)) 
[01:29:30.397]                             version <- utils::packageVersion("future")
[01:29:30.397]                         }
[01:29:30.397]                         else {
[01:29:30.397]                           version <- NULL
[01:29:30.397]                         }
[01:29:30.397]                         if (!has_future || version < "1.8.0") {
[01:29:30.397]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:30.397]                             "", base::R.version$version.string), 
[01:29:30.397]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:30.397]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:30.397]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:30.397]                               "release", "version")], collapse = " "), 
[01:29:30.397]                             hostname = base::Sys.info()[["nodename"]])
[01:29:30.397]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:30.397]                             info)
[01:29:30.397]                           info <- base::paste(info, collapse = "; ")
[01:29:30.397]                           if (!has_future) {
[01:29:30.397]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:30.397]                               info)
[01:29:30.397]                           }
[01:29:30.397]                           else {
[01:29:30.397]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:30.397]                               info, version)
[01:29:30.397]                           }
[01:29:30.397]                           base::stop(msg)
[01:29:30.397]                         }
[01:29:30.397]                       })
[01:29:30.397]                     }
[01:29:30.397]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:30.397]                     base::options(mc.cores = 1L)
[01:29:30.397]                   }
[01:29:30.397]                   options(future.plan = NULL)
[01:29:30.397]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.397]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:30.397]                 }
[01:29:30.397]                 ...future.workdir <- getwd()
[01:29:30.397]             }
[01:29:30.397]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:30.397]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:30.397]         }
[01:29:30.397]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:30.397]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:30.397]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:30.397]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:30.397]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:30.397]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:30.397]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:30.397]             base::names(...future.oldOptions))
[01:29:30.397]     }
[01:29:30.397]     if (FALSE) {
[01:29:30.397]     }
[01:29:30.397]     else {
[01:29:30.397]         if (TRUE) {
[01:29:30.397]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:30.397]                 open = "w")
[01:29:30.397]         }
[01:29:30.397]         else {
[01:29:30.397]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:30.397]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:30.397]         }
[01:29:30.397]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:30.397]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:30.397]             base::sink(type = "output", split = FALSE)
[01:29:30.397]             base::close(...future.stdout)
[01:29:30.397]         }, add = TRUE)
[01:29:30.397]     }
[01:29:30.397]     ...future.frame <- base::sys.nframe()
[01:29:30.397]     ...future.conditions <- base::list()
[01:29:30.397]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:30.397]     if (FALSE) {
[01:29:30.397]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:30.397]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:30.397]     }
[01:29:30.397]     ...future.result <- base::tryCatch({
[01:29:30.397]         base::withCallingHandlers({
[01:29:30.397]             ...future.value <- base::withVisible(base::local({
[01:29:30.397]                 ...future.makeSendCondition <- base::local({
[01:29:30.397]                   sendCondition <- NULL
[01:29:30.397]                   function(frame = 1L) {
[01:29:30.397]                     if (is.function(sendCondition)) 
[01:29:30.397]                       return(sendCondition)
[01:29:30.397]                     ns <- getNamespace("parallel")
[01:29:30.397]                     if (exists("sendData", mode = "function", 
[01:29:30.397]                       envir = ns)) {
[01:29:30.397]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:30.397]                         envir = ns)
[01:29:30.397]                       envir <- sys.frame(frame)
[01:29:30.397]                       master <- NULL
[01:29:30.397]                       while (!identical(envir, .GlobalEnv) && 
[01:29:30.397]                         !identical(envir, emptyenv())) {
[01:29:30.397]                         if (exists("master", mode = "list", envir = envir, 
[01:29:30.397]                           inherits = FALSE)) {
[01:29:30.397]                           master <- get("master", mode = "list", 
[01:29:30.397]                             envir = envir, inherits = FALSE)
[01:29:30.397]                           if (inherits(master, c("SOCKnode", 
[01:29:30.397]                             "SOCK0node"))) {
[01:29:30.397]                             sendCondition <<- function(cond) {
[01:29:30.397]                               data <- list(type = "VALUE", value = cond, 
[01:29:30.397]                                 success = TRUE)
[01:29:30.397]                               parallel_sendData(master, data)
[01:29:30.397]                             }
[01:29:30.397]                             return(sendCondition)
[01:29:30.397]                           }
[01:29:30.397]                         }
[01:29:30.397]                         frame <- frame + 1L
[01:29:30.397]                         envir <- sys.frame(frame)
[01:29:30.397]                       }
[01:29:30.397]                     }
[01:29:30.397]                     sendCondition <<- function(cond) NULL
[01:29:30.397]                   }
[01:29:30.397]                 })
[01:29:30.397]                 withCallingHandlers({
[01:29:30.397]                   {
[01:29:30.397]                     sample(x, size = 1L)
[01:29:30.397]                   }
[01:29:30.397]                 }, immediateCondition = function(cond) {
[01:29:30.397]                   sendCondition <- ...future.makeSendCondition()
[01:29:30.397]                   sendCondition(cond)
[01:29:30.397]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.397]                   {
[01:29:30.397]                     inherits <- base::inherits
[01:29:30.397]                     invokeRestart <- base::invokeRestart
[01:29:30.397]                     is.null <- base::is.null
[01:29:30.397]                     muffled <- FALSE
[01:29:30.397]                     if (inherits(cond, "message")) {
[01:29:30.397]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:30.397]                       if (muffled) 
[01:29:30.397]                         invokeRestart("muffleMessage")
[01:29:30.397]                     }
[01:29:30.397]                     else if (inherits(cond, "warning")) {
[01:29:30.397]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:30.397]                       if (muffled) 
[01:29:30.397]                         invokeRestart("muffleWarning")
[01:29:30.397]                     }
[01:29:30.397]                     else if (inherits(cond, "condition")) {
[01:29:30.397]                       if (!is.null(pattern)) {
[01:29:30.397]                         computeRestarts <- base::computeRestarts
[01:29:30.397]                         grepl <- base::grepl
[01:29:30.397]                         restarts <- computeRestarts(cond)
[01:29:30.397]                         for (restart in restarts) {
[01:29:30.397]                           name <- restart$name
[01:29:30.397]                           if (is.null(name)) 
[01:29:30.397]                             next
[01:29:30.397]                           if (!grepl(pattern, name)) 
[01:29:30.397]                             next
[01:29:30.397]                           invokeRestart(restart)
[01:29:30.397]                           muffled <- TRUE
[01:29:30.397]                           break
[01:29:30.397]                         }
[01:29:30.397]                       }
[01:29:30.397]                     }
[01:29:30.397]                     invisible(muffled)
[01:29:30.397]                   }
[01:29:30.397]                   muffleCondition(cond)
[01:29:30.397]                 })
[01:29:30.397]             }))
[01:29:30.397]             future::FutureResult(value = ...future.value$value, 
[01:29:30.397]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.397]                   ...future.rng), globalenv = if (FALSE) 
[01:29:30.397]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:30.397]                     ...future.globalenv.names))
[01:29:30.397]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:30.397]         }, condition = base::local({
[01:29:30.397]             c <- base::c
[01:29:30.397]             inherits <- base::inherits
[01:29:30.397]             invokeRestart <- base::invokeRestart
[01:29:30.397]             length <- base::length
[01:29:30.397]             list <- base::list
[01:29:30.397]             seq.int <- base::seq.int
[01:29:30.397]             signalCondition <- base::signalCondition
[01:29:30.397]             sys.calls <- base::sys.calls
[01:29:30.397]             `[[` <- base::`[[`
[01:29:30.397]             `+` <- base::`+`
[01:29:30.397]             `<<-` <- base::`<<-`
[01:29:30.397]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:30.397]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:30.397]                   3L)]
[01:29:30.397]             }
[01:29:30.397]             function(cond) {
[01:29:30.397]                 is_error <- inherits(cond, "error")
[01:29:30.397]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:30.397]                   NULL)
[01:29:30.397]                 if (is_error) {
[01:29:30.397]                   sessionInformation <- function() {
[01:29:30.397]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:30.397]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:30.397]                       search = base::search(), system = base::Sys.info())
[01:29:30.397]                   }
[01:29:30.397]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.397]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:30.397]                     cond$call), session = sessionInformation(), 
[01:29:30.397]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:30.397]                   signalCondition(cond)
[01:29:30.397]                 }
[01:29:30.397]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:30.397]                 "immediateCondition"))) {
[01:29:30.397]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:30.397]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.397]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:30.397]                   if (TRUE && !signal) {
[01:29:30.397]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.397]                     {
[01:29:30.397]                       inherits <- base::inherits
[01:29:30.397]                       invokeRestart <- base::invokeRestart
[01:29:30.397]                       is.null <- base::is.null
[01:29:30.397]                       muffled <- FALSE
[01:29:30.397]                       if (inherits(cond, "message")) {
[01:29:30.397]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.397]                         if (muffled) 
[01:29:30.397]                           invokeRestart("muffleMessage")
[01:29:30.397]                       }
[01:29:30.397]                       else if (inherits(cond, "warning")) {
[01:29:30.397]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.397]                         if (muffled) 
[01:29:30.397]                           invokeRestart("muffleWarning")
[01:29:30.397]                       }
[01:29:30.397]                       else if (inherits(cond, "condition")) {
[01:29:30.397]                         if (!is.null(pattern)) {
[01:29:30.397]                           computeRestarts <- base::computeRestarts
[01:29:30.397]                           grepl <- base::grepl
[01:29:30.397]                           restarts <- computeRestarts(cond)
[01:29:30.397]                           for (restart in restarts) {
[01:29:30.397]                             name <- restart$name
[01:29:30.397]                             if (is.null(name)) 
[01:29:30.397]                               next
[01:29:30.397]                             if (!grepl(pattern, name)) 
[01:29:30.397]                               next
[01:29:30.397]                             invokeRestart(restart)
[01:29:30.397]                             muffled <- TRUE
[01:29:30.397]                             break
[01:29:30.397]                           }
[01:29:30.397]                         }
[01:29:30.397]                       }
[01:29:30.397]                       invisible(muffled)
[01:29:30.397]                     }
[01:29:30.397]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.397]                   }
[01:29:30.397]                 }
[01:29:30.397]                 else {
[01:29:30.397]                   if (TRUE) {
[01:29:30.397]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.397]                     {
[01:29:30.397]                       inherits <- base::inherits
[01:29:30.397]                       invokeRestart <- base::invokeRestart
[01:29:30.397]                       is.null <- base::is.null
[01:29:30.397]                       muffled <- FALSE
[01:29:30.397]                       if (inherits(cond, "message")) {
[01:29:30.397]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.397]                         if (muffled) 
[01:29:30.397]                           invokeRestart("muffleMessage")
[01:29:30.397]                       }
[01:29:30.397]                       else if (inherits(cond, "warning")) {
[01:29:30.397]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.397]                         if (muffled) 
[01:29:30.397]                           invokeRestart("muffleWarning")
[01:29:30.397]                       }
[01:29:30.397]                       else if (inherits(cond, "condition")) {
[01:29:30.397]                         if (!is.null(pattern)) {
[01:29:30.397]                           computeRestarts <- base::computeRestarts
[01:29:30.397]                           grepl <- base::grepl
[01:29:30.397]                           restarts <- computeRestarts(cond)
[01:29:30.397]                           for (restart in restarts) {
[01:29:30.397]                             name <- restart$name
[01:29:30.397]                             if (is.null(name)) 
[01:29:30.397]                               next
[01:29:30.397]                             if (!grepl(pattern, name)) 
[01:29:30.397]                               next
[01:29:30.397]                             invokeRestart(restart)
[01:29:30.397]                             muffled <- TRUE
[01:29:30.397]                             break
[01:29:30.397]                           }
[01:29:30.397]                         }
[01:29:30.397]                       }
[01:29:30.397]                       invisible(muffled)
[01:29:30.397]                     }
[01:29:30.397]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.397]                   }
[01:29:30.397]                 }
[01:29:30.397]             }
[01:29:30.397]         }))
[01:29:30.397]     }, error = function(ex) {
[01:29:30.397]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:30.397]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.397]                 ...future.rng), started = ...future.startTime, 
[01:29:30.397]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:30.397]             version = "1.8"), class = "FutureResult")
[01:29:30.397]     }, finally = {
[01:29:30.397]         if (!identical(...future.workdir, getwd())) 
[01:29:30.397]             setwd(...future.workdir)
[01:29:30.397]         {
[01:29:30.397]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:30.397]                 ...future.oldOptions$nwarnings <- NULL
[01:29:30.397]             }
[01:29:30.397]             base::options(...future.oldOptions)
[01:29:30.397]             if (.Platform$OS.type == "windows") {
[01:29:30.397]                 old_names <- names(...future.oldEnvVars)
[01:29:30.397]                 envs <- base::Sys.getenv()
[01:29:30.397]                 names <- names(envs)
[01:29:30.397]                 common <- intersect(names, old_names)
[01:29:30.397]                 added <- setdiff(names, old_names)
[01:29:30.397]                 removed <- setdiff(old_names, names)
[01:29:30.397]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:30.397]                   envs[common]]
[01:29:30.397]                 NAMES <- toupper(changed)
[01:29:30.397]                 args <- list()
[01:29:30.397]                 for (kk in seq_along(NAMES)) {
[01:29:30.397]                   name <- changed[[kk]]
[01:29:30.397]                   NAME <- NAMES[[kk]]
[01:29:30.397]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.397]                     next
[01:29:30.397]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.397]                 }
[01:29:30.397]                 NAMES <- toupper(added)
[01:29:30.397]                 for (kk in seq_along(NAMES)) {
[01:29:30.397]                   name <- added[[kk]]
[01:29:30.397]                   NAME <- NAMES[[kk]]
[01:29:30.397]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.397]                     next
[01:29:30.397]                   args[[name]] <- ""
[01:29:30.397]                 }
[01:29:30.397]                 NAMES <- toupper(removed)
[01:29:30.397]                 for (kk in seq_along(NAMES)) {
[01:29:30.397]                   name <- removed[[kk]]
[01:29:30.397]                   NAME <- NAMES[[kk]]
[01:29:30.397]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.397]                     next
[01:29:30.397]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.397]                 }
[01:29:30.397]                 if (length(args) > 0) 
[01:29:30.397]                   base::do.call(base::Sys.setenv, args = args)
[01:29:30.397]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:30.397]             }
[01:29:30.397]             else {
[01:29:30.397]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:30.397]             }
[01:29:30.397]             {
[01:29:30.397]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:30.397]                   0L) {
[01:29:30.397]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:30.397]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:30.397]                   base::options(opts)
[01:29:30.397]                 }
[01:29:30.397]                 {
[01:29:30.397]                   {
[01:29:30.397]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:30.397]                     NULL
[01:29:30.397]                   }
[01:29:30.397]                   options(future.plan = NULL)
[01:29:30.397]                   if (is.na(NA_character_)) 
[01:29:30.397]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.397]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:30.397]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:30.397]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:30.397]                     envir = parent.frame()) 
[01:29:30.397]                   {
[01:29:30.397]                     if (is.function(workers)) 
[01:29:30.397]                       workers <- workers()
[01:29:30.397]                     workers <- structure(as.integer(workers), 
[01:29:30.397]                       class = class(workers))
[01:29:30.397]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:30.397]                       workers >= 1)
[01:29:30.397]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:30.397]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:30.397]                     }
[01:29:30.397]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:30.397]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:30.397]                       envir = envir)
[01:29:30.397]                     if (!future$lazy) 
[01:29:30.397]                       future <- run(future)
[01:29:30.397]                     invisible(future)
[01:29:30.397]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:30.397]                 }
[01:29:30.397]             }
[01:29:30.397]         }
[01:29:30.397]     })
[01:29:30.397]     if (TRUE) {
[01:29:30.397]         base::sink(type = "output", split = FALSE)
[01:29:30.397]         if (TRUE) {
[01:29:30.397]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:30.397]         }
[01:29:30.397]         else {
[01:29:30.397]             ...future.result["stdout"] <- base::list(NULL)
[01:29:30.397]         }
[01:29:30.397]         base::close(...future.stdout)
[01:29:30.397]         ...future.stdout <- NULL
[01:29:30.397]     }
[01:29:30.397]     ...future.result$conditions <- ...future.conditions
[01:29:30.397]     ...future.result$finished <- base::Sys.time()
[01:29:30.397]     ...future.result
[01:29:30.397] }
[01:29:30.404] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:30.404] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:30.405] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:30.405] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:30.406] MultisessionFuture started
[01:29:30.406] - Launch lazy future ... done
[01:29:30.406] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_1-988817'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96d8755a8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[01:29:30.423] receiveMessageFromWorker() for ClusterFuture ...
[01:29:30.423] - Validating connection of MultisessionFuture
[01:29:30.424] - received message: FutureResult
[01:29:30.424] - Received FutureResult
[01:29:30.424] - Erased future from FutureRegistry
[01:29:30.425] result() for ClusterFuture ...
[01:29:30.425] - result already collected: FutureResult
[01:29:30.425] result() for ClusterFuture ... done
[01:29:30.425] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.426] getGlobalsAndPackages() ...
[01:29:30.426] Searching for globals...
[01:29:30.428] - globals found: [3] '{', 'sample', 'x'
[01:29:30.428] Searching for globals ... DONE
[01:29:30.428] Resolving globals: FALSE
[01:29:30.429] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:30.429] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:30.430] - globals: [1] 'x'
[01:29:30.430] 
[01:29:30.430] getGlobalsAndPackages() ... DONE
[01:29:30.431] run() for 'Future' ...
[01:29:30.431] - state: 'created'
[01:29:30.431] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:30.447] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.447] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:30.447]   - Field: 'node'
[01:29:30.448]   - Field: 'label'
[01:29:30.448]   - Field: 'local'
[01:29:30.448]   - Field: 'owner'
[01:29:30.448]   - Field: 'envir'
[01:29:30.448]   - Field: 'workers'
[01:29:30.449]   - Field: 'packages'
[01:29:30.449]   - Field: 'gc'
[01:29:30.449]   - Field: 'conditions'
[01:29:30.449]   - Field: 'persistent'
[01:29:30.449]   - Field: 'expr'
[01:29:30.450]   - Field: 'uuid'
[01:29:30.450]   - Field: 'seed'
[01:29:30.450]   - Field: 'version'
[01:29:30.450]   - Field: 'result'
[01:29:30.450]   - Field: 'asynchronous'
[01:29:30.451]   - Field: 'calls'
[01:29:30.451]   - Field: 'globals'
[01:29:30.451]   - Field: 'stdout'
[01:29:30.451]   - Field: 'earlySignal'
[01:29:30.452]   - Field: 'lazy'
[01:29:30.452]   - Field: 'state'
[01:29:30.452] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:30.452] - Launch lazy future ...
[01:29:30.453] Packages needed by the future expression (n = 0): <none>
[01:29:30.453] Packages needed by future strategies (n = 0): <none>
[01:29:30.454] {
[01:29:30.454]     {
[01:29:30.454]         {
[01:29:30.454]             ...future.startTime <- base::Sys.time()
[01:29:30.454]             {
[01:29:30.454]                 {
[01:29:30.454]                   {
[01:29:30.454]                     {
[01:29:30.454]                       base::local({
[01:29:30.454]                         has_future <- base::requireNamespace("future", 
[01:29:30.454]                           quietly = TRUE)
[01:29:30.454]                         if (has_future) {
[01:29:30.454]                           ns <- base::getNamespace("future")
[01:29:30.454]                           version <- ns[[".package"]][["version"]]
[01:29:30.454]                           if (is.null(version)) 
[01:29:30.454]                             version <- utils::packageVersion("future")
[01:29:30.454]                         }
[01:29:30.454]                         else {
[01:29:30.454]                           version <- NULL
[01:29:30.454]                         }
[01:29:30.454]                         if (!has_future || version < "1.8.0") {
[01:29:30.454]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:30.454]                             "", base::R.version$version.string), 
[01:29:30.454]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:30.454]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:30.454]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:30.454]                               "release", "version")], collapse = " "), 
[01:29:30.454]                             hostname = base::Sys.info()[["nodename"]])
[01:29:30.454]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:30.454]                             info)
[01:29:30.454]                           info <- base::paste(info, collapse = "; ")
[01:29:30.454]                           if (!has_future) {
[01:29:30.454]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:30.454]                               info)
[01:29:30.454]                           }
[01:29:30.454]                           else {
[01:29:30.454]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:30.454]                               info, version)
[01:29:30.454]                           }
[01:29:30.454]                           base::stop(msg)
[01:29:30.454]                         }
[01:29:30.454]                       })
[01:29:30.454]                     }
[01:29:30.454]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:30.454]                     base::options(mc.cores = 1L)
[01:29:30.454]                   }
[01:29:30.454]                   options(future.plan = NULL)
[01:29:30.454]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.454]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:30.454]                 }
[01:29:30.454]                 ...future.workdir <- getwd()
[01:29:30.454]             }
[01:29:30.454]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:30.454]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:30.454]         }
[01:29:30.454]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:30.454]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:30.454]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:30.454]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:30.454]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:30.454]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:30.454]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:30.454]             base::names(...future.oldOptions))
[01:29:30.454]     }
[01:29:30.454]     if (FALSE) {
[01:29:30.454]     }
[01:29:30.454]     else {
[01:29:30.454]         if (TRUE) {
[01:29:30.454]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:30.454]                 open = "w")
[01:29:30.454]         }
[01:29:30.454]         else {
[01:29:30.454]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:30.454]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:30.454]         }
[01:29:30.454]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:30.454]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:30.454]             base::sink(type = "output", split = FALSE)
[01:29:30.454]             base::close(...future.stdout)
[01:29:30.454]         }, add = TRUE)
[01:29:30.454]     }
[01:29:30.454]     ...future.frame <- base::sys.nframe()
[01:29:30.454]     ...future.conditions <- base::list()
[01:29:30.454]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:30.454]     if (FALSE) {
[01:29:30.454]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:30.454]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:30.454]     }
[01:29:30.454]     ...future.result <- base::tryCatch({
[01:29:30.454]         base::withCallingHandlers({
[01:29:30.454]             ...future.value <- base::withVisible(base::local({
[01:29:30.454]                 ...future.makeSendCondition <- base::local({
[01:29:30.454]                   sendCondition <- NULL
[01:29:30.454]                   function(frame = 1L) {
[01:29:30.454]                     if (is.function(sendCondition)) 
[01:29:30.454]                       return(sendCondition)
[01:29:30.454]                     ns <- getNamespace("parallel")
[01:29:30.454]                     if (exists("sendData", mode = "function", 
[01:29:30.454]                       envir = ns)) {
[01:29:30.454]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:30.454]                         envir = ns)
[01:29:30.454]                       envir <- sys.frame(frame)
[01:29:30.454]                       master <- NULL
[01:29:30.454]                       while (!identical(envir, .GlobalEnv) && 
[01:29:30.454]                         !identical(envir, emptyenv())) {
[01:29:30.454]                         if (exists("master", mode = "list", envir = envir, 
[01:29:30.454]                           inherits = FALSE)) {
[01:29:30.454]                           master <- get("master", mode = "list", 
[01:29:30.454]                             envir = envir, inherits = FALSE)
[01:29:30.454]                           if (inherits(master, c("SOCKnode", 
[01:29:30.454]                             "SOCK0node"))) {
[01:29:30.454]                             sendCondition <<- function(cond) {
[01:29:30.454]                               data <- list(type = "VALUE", value = cond, 
[01:29:30.454]                                 success = TRUE)
[01:29:30.454]                               parallel_sendData(master, data)
[01:29:30.454]                             }
[01:29:30.454]                             return(sendCondition)
[01:29:30.454]                           }
[01:29:30.454]                         }
[01:29:30.454]                         frame <- frame + 1L
[01:29:30.454]                         envir <- sys.frame(frame)
[01:29:30.454]                       }
[01:29:30.454]                     }
[01:29:30.454]                     sendCondition <<- function(cond) NULL
[01:29:30.454]                   }
[01:29:30.454]                 })
[01:29:30.454]                 withCallingHandlers({
[01:29:30.454]                   {
[01:29:30.454]                     sample(x, size = 1L)
[01:29:30.454]                   }
[01:29:30.454]                 }, immediateCondition = function(cond) {
[01:29:30.454]                   sendCondition <- ...future.makeSendCondition()
[01:29:30.454]                   sendCondition(cond)
[01:29:30.454]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.454]                   {
[01:29:30.454]                     inherits <- base::inherits
[01:29:30.454]                     invokeRestart <- base::invokeRestart
[01:29:30.454]                     is.null <- base::is.null
[01:29:30.454]                     muffled <- FALSE
[01:29:30.454]                     if (inherits(cond, "message")) {
[01:29:30.454]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:30.454]                       if (muffled) 
[01:29:30.454]                         invokeRestart("muffleMessage")
[01:29:30.454]                     }
[01:29:30.454]                     else if (inherits(cond, "warning")) {
[01:29:30.454]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:30.454]                       if (muffled) 
[01:29:30.454]                         invokeRestart("muffleWarning")
[01:29:30.454]                     }
[01:29:30.454]                     else if (inherits(cond, "condition")) {
[01:29:30.454]                       if (!is.null(pattern)) {
[01:29:30.454]                         computeRestarts <- base::computeRestarts
[01:29:30.454]                         grepl <- base::grepl
[01:29:30.454]                         restarts <- computeRestarts(cond)
[01:29:30.454]                         for (restart in restarts) {
[01:29:30.454]                           name <- restart$name
[01:29:30.454]                           if (is.null(name)) 
[01:29:30.454]                             next
[01:29:30.454]                           if (!grepl(pattern, name)) 
[01:29:30.454]                             next
[01:29:30.454]                           invokeRestart(restart)
[01:29:30.454]                           muffled <- TRUE
[01:29:30.454]                           break
[01:29:30.454]                         }
[01:29:30.454]                       }
[01:29:30.454]                     }
[01:29:30.454]                     invisible(muffled)
[01:29:30.454]                   }
[01:29:30.454]                   muffleCondition(cond)
[01:29:30.454]                 })
[01:29:30.454]             }))
[01:29:30.454]             future::FutureResult(value = ...future.value$value, 
[01:29:30.454]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.454]                   ...future.rng), globalenv = if (FALSE) 
[01:29:30.454]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:30.454]                     ...future.globalenv.names))
[01:29:30.454]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:30.454]         }, condition = base::local({
[01:29:30.454]             c <- base::c
[01:29:30.454]             inherits <- base::inherits
[01:29:30.454]             invokeRestart <- base::invokeRestart
[01:29:30.454]             length <- base::length
[01:29:30.454]             list <- base::list
[01:29:30.454]             seq.int <- base::seq.int
[01:29:30.454]             signalCondition <- base::signalCondition
[01:29:30.454]             sys.calls <- base::sys.calls
[01:29:30.454]             `[[` <- base::`[[`
[01:29:30.454]             `+` <- base::`+`
[01:29:30.454]             `<<-` <- base::`<<-`
[01:29:30.454]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:30.454]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:30.454]                   3L)]
[01:29:30.454]             }
[01:29:30.454]             function(cond) {
[01:29:30.454]                 is_error <- inherits(cond, "error")
[01:29:30.454]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:30.454]                   NULL)
[01:29:30.454]                 if (is_error) {
[01:29:30.454]                   sessionInformation <- function() {
[01:29:30.454]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:30.454]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:30.454]                       search = base::search(), system = base::Sys.info())
[01:29:30.454]                   }
[01:29:30.454]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.454]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:30.454]                     cond$call), session = sessionInformation(), 
[01:29:30.454]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:30.454]                   signalCondition(cond)
[01:29:30.454]                 }
[01:29:30.454]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:30.454]                 "immediateCondition"))) {
[01:29:30.454]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:30.454]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.454]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:30.454]                   if (TRUE && !signal) {
[01:29:30.454]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.454]                     {
[01:29:30.454]                       inherits <- base::inherits
[01:29:30.454]                       invokeRestart <- base::invokeRestart
[01:29:30.454]                       is.null <- base::is.null
[01:29:30.454]                       muffled <- FALSE
[01:29:30.454]                       if (inherits(cond, "message")) {
[01:29:30.454]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.454]                         if (muffled) 
[01:29:30.454]                           invokeRestart("muffleMessage")
[01:29:30.454]                       }
[01:29:30.454]                       else if (inherits(cond, "warning")) {
[01:29:30.454]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.454]                         if (muffled) 
[01:29:30.454]                           invokeRestart("muffleWarning")
[01:29:30.454]                       }
[01:29:30.454]                       else if (inherits(cond, "condition")) {
[01:29:30.454]                         if (!is.null(pattern)) {
[01:29:30.454]                           computeRestarts <- base::computeRestarts
[01:29:30.454]                           grepl <- base::grepl
[01:29:30.454]                           restarts <- computeRestarts(cond)
[01:29:30.454]                           for (restart in restarts) {
[01:29:30.454]                             name <- restart$name
[01:29:30.454]                             if (is.null(name)) 
[01:29:30.454]                               next
[01:29:30.454]                             if (!grepl(pattern, name)) 
[01:29:30.454]                               next
[01:29:30.454]                             invokeRestart(restart)
[01:29:30.454]                             muffled <- TRUE
[01:29:30.454]                             break
[01:29:30.454]                           }
[01:29:30.454]                         }
[01:29:30.454]                       }
[01:29:30.454]                       invisible(muffled)
[01:29:30.454]                     }
[01:29:30.454]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.454]                   }
[01:29:30.454]                 }
[01:29:30.454]                 else {
[01:29:30.454]                   if (TRUE) {
[01:29:30.454]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.454]                     {
[01:29:30.454]                       inherits <- base::inherits
[01:29:30.454]                       invokeRestart <- base::invokeRestart
[01:29:30.454]                       is.null <- base::is.null
[01:29:30.454]                       muffled <- FALSE
[01:29:30.454]                       if (inherits(cond, "message")) {
[01:29:30.454]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.454]                         if (muffled) 
[01:29:30.454]                           invokeRestart("muffleMessage")
[01:29:30.454]                       }
[01:29:30.454]                       else if (inherits(cond, "warning")) {
[01:29:30.454]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.454]                         if (muffled) 
[01:29:30.454]                           invokeRestart("muffleWarning")
[01:29:30.454]                       }
[01:29:30.454]                       else if (inherits(cond, "condition")) {
[01:29:30.454]                         if (!is.null(pattern)) {
[01:29:30.454]                           computeRestarts <- base::computeRestarts
[01:29:30.454]                           grepl <- base::grepl
[01:29:30.454]                           restarts <- computeRestarts(cond)
[01:29:30.454]                           for (restart in restarts) {
[01:29:30.454]                             name <- restart$name
[01:29:30.454]                             if (is.null(name)) 
[01:29:30.454]                               next
[01:29:30.454]                             if (!grepl(pattern, name)) 
[01:29:30.454]                               next
[01:29:30.454]                             invokeRestart(restart)
[01:29:30.454]                             muffled <- TRUE
[01:29:30.454]                             break
[01:29:30.454]                           }
[01:29:30.454]                         }
[01:29:30.454]                       }
[01:29:30.454]                       invisible(muffled)
[01:29:30.454]                     }
[01:29:30.454]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.454]                   }
[01:29:30.454]                 }
[01:29:30.454]             }
[01:29:30.454]         }))
[01:29:30.454]     }, error = function(ex) {
[01:29:30.454]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:30.454]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.454]                 ...future.rng), started = ...future.startTime, 
[01:29:30.454]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:30.454]             version = "1.8"), class = "FutureResult")
[01:29:30.454]     }, finally = {
[01:29:30.454]         if (!identical(...future.workdir, getwd())) 
[01:29:30.454]             setwd(...future.workdir)
[01:29:30.454]         {
[01:29:30.454]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:30.454]                 ...future.oldOptions$nwarnings <- NULL
[01:29:30.454]             }
[01:29:30.454]             base::options(...future.oldOptions)
[01:29:30.454]             if (.Platform$OS.type == "windows") {
[01:29:30.454]                 old_names <- names(...future.oldEnvVars)
[01:29:30.454]                 envs <- base::Sys.getenv()
[01:29:30.454]                 names <- names(envs)
[01:29:30.454]                 common <- intersect(names, old_names)
[01:29:30.454]                 added <- setdiff(names, old_names)
[01:29:30.454]                 removed <- setdiff(old_names, names)
[01:29:30.454]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:30.454]                   envs[common]]
[01:29:30.454]                 NAMES <- toupper(changed)
[01:29:30.454]                 args <- list()
[01:29:30.454]                 for (kk in seq_along(NAMES)) {
[01:29:30.454]                   name <- changed[[kk]]
[01:29:30.454]                   NAME <- NAMES[[kk]]
[01:29:30.454]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.454]                     next
[01:29:30.454]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.454]                 }
[01:29:30.454]                 NAMES <- toupper(added)
[01:29:30.454]                 for (kk in seq_along(NAMES)) {
[01:29:30.454]                   name <- added[[kk]]
[01:29:30.454]                   NAME <- NAMES[[kk]]
[01:29:30.454]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.454]                     next
[01:29:30.454]                   args[[name]] <- ""
[01:29:30.454]                 }
[01:29:30.454]                 NAMES <- toupper(removed)
[01:29:30.454]                 for (kk in seq_along(NAMES)) {
[01:29:30.454]                   name <- removed[[kk]]
[01:29:30.454]                   NAME <- NAMES[[kk]]
[01:29:30.454]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.454]                     next
[01:29:30.454]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.454]                 }
[01:29:30.454]                 if (length(args) > 0) 
[01:29:30.454]                   base::do.call(base::Sys.setenv, args = args)
[01:29:30.454]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:30.454]             }
[01:29:30.454]             else {
[01:29:30.454]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:30.454]             }
[01:29:30.454]             {
[01:29:30.454]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:30.454]                   0L) {
[01:29:30.454]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:30.454]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:30.454]                   base::options(opts)
[01:29:30.454]                 }
[01:29:30.454]                 {
[01:29:30.454]                   {
[01:29:30.454]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:30.454]                     NULL
[01:29:30.454]                   }
[01:29:30.454]                   options(future.plan = NULL)
[01:29:30.454]                   if (is.na(NA_character_)) 
[01:29:30.454]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.454]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:30.454]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:30.454]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:30.454]                     envir = parent.frame()) 
[01:29:30.454]                   {
[01:29:30.454]                     if (is.function(workers)) 
[01:29:30.454]                       workers <- workers()
[01:29:30.454]                     workers <- structure(as.integer(workers), 
[01:29:30.454]                       class = class(workers))
[01:29:30.454]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:30.454]                       workers >= 1)
[01:29:30.454]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:30.454]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:30.454]                     }
[01:29:30.454]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:30.454]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:30.454]                       envir = envir)
[01:29:30.454]                     if (!future$lazy) 
[01:29:30.454]                       future <- run(future)
[01:29:30.454]                     invisible(future)
[01:29:30.454]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:30.454]                 }
[01:29:30.454]             }
[01:29:30.454]         }
[01:29:30.454]     })
[01:29:30.454]     if (TRUE) {
[01:29:30.454]         base::sink(type = "output", split = FALSE)
[01:29:30.454]         if (TRUE) {
[01:29:30.454]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:30.454]         }
[01:29:30.454]         else {
[01:29:30.454]             ...future.result["stdout"] <- base::list(NULL)
[01:29:30.454]         }
[01:29:30.454]         base::close(...future.stdout)
[01:29:30.454]         ...future.stdout <- NULL
[01:29:30.454]     }
[01:29:30.454]     ...future.result$conditions <- ...future.conditions
[01:29:30.454]     ...future.result$finished <- base::Sys.time()
[01:29:30.454]     ...future.result
[01:29:30.454] }
[01:29:30.460] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:30.460] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:30.461] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:30.461] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:30.462] MultisessionFuture started
[01:29:30.462] - Launch lazy future ... done
[01:29:30.462] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_2-256483'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96d8755a8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[01:29:30.478] receiveMessageFromWorker() for ClusterFuture ...
[01:29:30.479] - Validating connection of MultisessionFuture
[01:29:30.479] - received message: FutureResult
[01:29:30.479] - Received FutureResult
[01:29:30.480] - Erased future from FutureRegistry
[01:29:30.480] result() for ClusterFuture ...
[01:29:30.480] - result already collected: FutureResult
[01:29:30.480] result() for ClusterFuture ... done
[01:29:30.480] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.481] getGlobalsAndPackages() ...
[01:29:30.481] Searching for globals...
[01:29:30.482] - globals found: [3] '{', 'sample', 'x'
[01:29:30.483] Searching for globals ... DONE
[01:29:30.483] Resolving globals: FALSE
[01:29:30.483] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:30.484] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:30.484] - globals: [1] 'x'
[01:29:30.484] 
[01:29:30.485] getGlobalsAndPackages() ... DONE
[01:29:30.485] run() for 'Future' ...
[01:29:30.485] - state: 'created'
[01:29:30.486] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:30.501] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.502] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:30.502]   - Field: 'node'
[01:29:30.502]   - Field: 'label'
[01:29:30.502]   - Field: 'local'
[01:29:30.502]   - Field: 'owner'
[01:29:30.503]   - Field: 'envir'
[01:29:30.503]   - Field: 'workers'
[01:29:30.503]   - Field: 'packages'
[01:29:30.503]   - Field: 'gc'
[01:29:30.503]   - Field: 'conditions'
[01:29:30.504]   - Field: 'persistent'
[01:29:30.504]   - Field: 'expr'
[01:29:30.504]   - Field: 'uuid'
[01:29:30.504]   - Field: 'seed'
[01:29:30.504]   - Field: 'version'
[01:29:30.504]   - Field: 'result'
[01:29:30.505]   - Field: 'asynchronous'
[01:29:30.505]   - Field: 'calls'
[01:29:30.505]   - Field: 'globals'
[01:29:30.505]   - Field: 'stdout'
[01:29:30.505]   - Field: 'earlySignal'
[01:29:30.506]   - Field: 'lazy'
[01:29:30.506]   - Field: 'state'
[01:29:30.506] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:30.506] - Launch lazy future ...
[01:29:30.506] Packages needed by the future expression (n = 0): <none>
[01:29:30.507] Packages needed by future strategies (n = 0): <none>
[01:29:30.507] {
[01:29:30.507]     {
[01:29:30.507]         {
[01:29:30.507]             ...future.startTime <- base::Sys.time()
[01:29:30.507]             {
[01:29:30.507]                 {
[01:29:30.507]                   {
[01:29:30.507]                     {
[01:29:30.507]                       base::local({
[01:29:30.507]                         has_future <- base::requireNamespace("future", 
[01:29:30.507]                           quietly = TRUE)
[01:29:30.507]                         if (has_future) {
[01:29:30.507]                           ns <- base::getNamespace("future")
[01:29:30.507]                           version <- ns[[".package"]][["version"]]
[01:29:30.507]                           if (is.null(version)) 
[01:29:30.507]                             version <- utils::packageVersion("future")
[01:29:30.507]                         }
[01:29:30.507]                         else {
[01:29:30.507]                           version <- NULL
[01:29:30.507]                         }
[01:29:30.507]                         if (!has_future || version < "1.8.0") {
[01:29:30.507]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:30.507]                             "", base::R.version$version.string), 
[01:29:30.507]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:30.507]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:30.507]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:30.507]                               "release", "version")], collapse = " "), 
[01:29:30.507]                             hostname = base::Sys.info()[["nodename"]])
[01:29:30.507]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:30.507]                             info)
[01:29:30.507]                           info <- base::paste(info, collapse = "; ")
[01:29:30.507]                           if (!has_future) {
[01:29:30.507]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:30.507]                               info)
[01:29:30.507]                           }
[01:29:30.507]                           else {
[01:29:30.507]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:30.507]                               info, version)
[01:29:30.507]                           }
[01:29:30.507]                           base::stop(msg)
[01:29:30.507]                         }
[01:29:30.507]                       })
[01:29:30.507]                     }
[01:29:30.507]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:30.507]                     base::options(mc.cores = 1L)
[01:29:30.507]                   }
[01:29:30.507]                   options(future.plan = NULL)
[01:29:30.507]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.507]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:30.507]                 }
[01:29:30.507]                 ...future.workdir <- getwd()
[01:29:30.507]             }
[01:29:30.507]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:30.507]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:30.507]         }
[01:29:30.507]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:30.507]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:30.507]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:30.507]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:30.507]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:30.507]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:30.507]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:30.507]             base::names(...future.oldOptions))
[01:29:30.507]     }
[01:29:30.507]     if (FALSE) {
[01:29:30.507]     }
[01:29:30.507]     else {
[01:29:30.507]         if (TRUE) {
[01:29:30.507]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:30.507]                 open = "w")
[01:29:30.507]         }
[01:29:30.507]         else {
[01:29:30.507]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:30.507]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:30.507]         }
[01:29:30.507]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:30.507]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:30.507]             base::sink(type = "output", split = FALSE)
[01:29:30.507]             base::close(...future.stdout)
[01:29:30.507]         }, add = TRUE)
[01:29:30.507]     }
[01:29:30.507]     ...future.frame <- base::sys.nframe()
[01:29:30.507]     ...future.conditions <- base::list()
[01:29:30.507]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:30.507]     if (FALSE) {
[01:29:30.507]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:30.507]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:30.507]     }
[01:29:30.507]     ...future.result <- base::tryCatch({
[01:29:30.507]         base::withCallingHandlers({
[01:29:30.507]             ...future.value <- base::withVisible(base::local({
[01:29:30.507]                 ...future.makeSendCondition <- base::local({
[01:29:30.507]                   sendCondition <- NULL
[01:29:30.507]                   function(frame = 1L) {
[01:29:30.507]                     if (is.function(sendCondition)) 
[01:29:30.507]                       return(sendCondition)
[01:29:30.507]                     ns <- getNamespace("parallel")
[01:29:30.507]                     if (exists("sendData", mode = "function", 
[01:29:30.507]                       envir = ns)) {
[01:29:30.507]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:30.507]                         envir = ns)
[01:29:30.507]                       envir <- sys.frame(frame)
[01:29:30.507]                       master <- NULL
[01:29:30.507]                       while (!identical(envir, .GlobalEnv) && 
[01:29:30.507]                         !identical(envir, emptyenv())) {
[01:29:30.507]                         if (exists("master", mode = "list", envir = envir, 
[01:29:30.507]                           inherits = FALSE)) {
[01:29:30.507]                           master <- get("master", mode = "list", 
[01:29:30.507]                             envir = envir, inherits = FALSE)
[01:29:30.507]                           if (inherits(master, c("SOCKnode", 
[01:29:30.507]                             "SOCK0node"))) {
[01:29:30.507]                             sendCondition <<- function(cond) {
[01:29:30.507]                               data <- list(type = "VALUE", value = cond, 
[01:29:30.507]                                 success = TRUE)
[01:29:30.507]                               parallel_sendData(master, data)
[01:29:30.507]                             }
[01:29:30.507]                             return(sendCondition)
[01:29:30.507]                           }
[01:29:30.507]                         }
[01:29:30.507]                         frame <- frame + 1L
[01:29:30.507]                         envir <- sys.frame(frame)
[01:29:30.507]                       }
[01:29:30.507]                     }
[01:29:30.507]                     sendCondition <<- function(cond) NULL
[01:29:30.507]                   }
[01:29:30.507]                 })
[01:29:30.507]                 withCallingHandlers({
[01:29:30.507]                   {
[01:29:30.507]                     sample(x, size = 1L)
[01:29:30.507]                   }
[01:29:30.507]                 }, immediateCondition = function(cond) {
[01:29:30.507]                   sendCondition <- ...future.makeSendCondition()
[01:29:30.507]                   sendCondition(cond)
[01:29:30.507]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.507]                   {
[01:29:30.507]                     inherits <- base::inherits
[01:29:30.507]                     invokeRestart <- base::invokeRestart
[01:29:30.507]                     is.null <- base::is.null
[01:29:30.507]                     muffled <- FALSE
[01:29:30.507]                     if (inherits(cond, "message")) {
[01:29:30.507]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:30.507]                       if (muffled) 
[01:29:30.507]                         invokeRestart("muffleMessage")
[01:29:30.507]                     }
[01:29:30.507]                     else if (inherits(cond, "warning")) {
[01:29:30.507]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:30.507]                       if (muffled) 
[01:29:30.507]                         invokeRestart("muffleWarning")
[01:29:30.507]                     }
[01:29:30.507]                     else if (inherits(cond, "condition")) {
[01:29:30.507]                       if (!is.null(pattern)) {
[01:29:30.507]                         computeRestarts <- base::computeRestarts
[01:29:30.507]                         grepl <- base::grepl
[01:29:30.507]                         restarts <- computeRestarts(cond)
[01:29:30.507]                         for (restart in restarts) {
[01:29:30.507]                           name <- restart$name
[01:29:30.507]                           if (is.null(name)) 
[01:29:30.507]                             next
[01:29:30.507]                           if (!grepl(pattern, name)) 
[01:29:30.507]                             next
[01:29:30.507]                           invokeRestart(restart)
[01:29:30.507]                           muffled <- TRUE
[01:29:30.507]                           break
[01:29:30.507]                         }
[01:29:30.507]                       }
[01:29:30.507]                     }
[01:29:30.507]                     invisible(muffled)
[01:29:30.507]                   }
[01:29:30.507]                   muffleCondition(cond)
[01:29:30.507]                 })
[01:29:30.507]             }))
[01:29:30.507]             future::FutureResult(value = ...future.value$value, 
[01:29:30.507]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.507]                   ...future.rng), globalenv = if (FALSE) 
[01:29:30.507]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:30.507]                     ...future.globalenv.names))
[01:29:30.507]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:30.507]         }, condition = base::local({
[01:29:30.507]             c <- base::c
[01:29:30.507]             inherits <- base::inherits
[01:29:30.507]             invokeRestart <- base::invokeRestart
[01:29:30.507]             length <- base::length
[01:29:30.507]             list <- base::list
[01:29:30.507]             seq.int <- base::seq.int
[01:29:30.507]             signalCondition <- base::signalCondition
[01:29:30.507]             sys.calls <- base::sys.calls
[01:29:30.507]             `[[` <- base::`[[`
[01:29:30.507]             `+` <- base::`+`
[01:29:30.507]             `<<-` <- base::`<<-`
[01:29:30.507]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:30.507]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:30.507]                   3L)]
[01:29:30.507]             }
[01:29:30.507]             function(cond) {
[01:29:30.507]                 is_error <- inherits(cond, "error")
[01:29:30.507]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:30.507]                   NULL)
[01:29:30.507]                 if (is_error) {
[01:29:30.507]                   sessionInformation <- function() {
[01:29:30.507]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:30.507]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:30.507]                       search = base::search(), system = base::Sys.info())
[01:29:30.507]                   }
[01:29:30.507]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.507]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:30.507]                     cond$call), session = sessionInformation(), 
[01:29:30.507]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:30.507]                   signalCondition(cond)
[01:29:30.507]                 }
[01:29:30.507]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:30.507]                 "immediateCondition"))) {
[01:29:30.507]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:30.507]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.507]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:30.507]                   if (TRUE && !signal) {
[01:29:30.507]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.507]                     {
[01:29:30.507]                       inherits <- base::inherits
[01:29:30.507]                       invokeRestart <- base::invokeRestart
[01:29:30.507]                       is.null <- base::is.null
[01:29:30.507]                       muffled <- FALSE
[01:29:30.507]                       if (inherits(cond, "message")) {
[01:29:30.507]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.507]                         if (muffled) 
[01:29:30.507]                           invokeRestart("muffleMessage")
[01:29:30.507]                       }
[01:29:30.507]                       else if (inherits(cond, "warning")) {
[01:29:30.507]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.507]                         if (muffled) 
[01:29:30.507]                           invokeRestart("muffleWarning")
[01:29:30.507]                       }
[01:29:30.507]                       else if (inherits(cond, "condition")) {
[01:29:30.507]                         if (!is.null(pattern)) {
[01:29:30.507]                           computeRestarts <- base::computeRestarts
[01:29:30.507]                           grepl <- base::grepl
[01:29:30.507]                           restarts <- computeRestarts(cond)
[01:29:30.507]                           for (restart in restarts) {
[01:29:30.507]                             name <- restart$name
[01:29:30.507]                             if (is.null(name)) 
[01:29:30.507]                               next
[01:29:30.507]                             if (!grepl(pattern, name)) 
[01:29:30.507]                               next
[01:29:30.507]                             invokeRestart(restart)
[01:29:30.507]                             muffled <- TRUE
[01:29:30.507]                             break
[01:29:30.507]                           }
[01:29:30.507]                         }
[01:29:30.507]                       }
[01:29:30.507]                       invisible(muffled)
[01:29:30.507]                     }
[01:29:30.507]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.507]                   }
[01:29:30.507]                 }
[01:29:30.507]                 else {
[01:29:30.507]                   if (TRUE) {
[01:29:30.507]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.507]                     {
[01:29:30.507]                       inherits <- base::inherits
[01:29:30.507]                       invokeRestart <- base::invokeRestart
[01:29:30.507]                       is.null <- base::is.null
[01:29:30.507]                       muffled <- FALSE
[01:29:30.507]                       if (inherits(cond, "message")) {
[01:29:30.507]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.507]                         if (muffled) 
[01:29:30.507]                           invokeRestart("muffleMessage")
[01:29:30.507]                       }
[01:29:30.507]                       else if (inherits(cond, "warning")) {
[01:29:30.507]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.507]                         if (muffled) 
[01:29:30.507]                           invokeRestart("muffleWarning")
[01:29:30.507]                       }
[01:29:30.507]                       else if (inherits(cond, "condition")) {
[01:29:30.507]                         if (!is.null(pattern)) {
[01:29:30.507]                           computeRestarts <- base::computeRestarts
[01:29:30.507]                           grepl <- base::grepl
[01:29:30.507]                           restarts <- computeRestarts(cond)
[01:29:30.507]                           for (restart in restarts) {
[01:29:30.507]                             name <- restart$name
[01:29:30.507]                             if (is.null(name)) 
[01:29:30.507]                               next
[01:29:30.507]                             if (!grepl(pattern, name)) 
[01:29:30.507]                               next
[01:29:30.507]                             invokeRestart(restart)
[01:29:30.507]                             muffled <- TRUE
[01:29:30.507]                             break
[01:29:30.507]                           }
[01:29:30.507]                         }
[01:29:30.507]                       }
[01:29:30.507]                       invisible(muffled)
[01:29:30.507]                     }
[01:29:30.507]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.507]                   }
[01:29:30.507]                 }
[01:29:30.507]             }
[01:29:30.507]         }))
[01:29:30.507]     }, error = function(ex) {
[01:29:30.507]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:30.507]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.507]                 ...future.rng), started = ...future.startTime, 
[01:29:30.507]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:30.507]             version = "1.8"), class = "FutureResult")
[01:29:30.507]     }, finally = {
[01:29:30.507]         if (!identical(...future.workdir, getwd())) 
[01:29:30.507]             setwd(...future.workdir)
[01:29:30.507]         {
[01:29:30.507]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:30.507]                 ...future.oldOptions$nwarnings <- NULL
[01:29:30.507]             }
[01:29:30.507]             base::options(...future.oldOptions)
[01:29:30.507]             if (.Platform$OS.type == "windows") {
[01:29:30.507]                 old_names <- names(...future.oldEnvVars)
[01:29:30.507]                 envs <- base::Sys.getenv()
[01:29:30.507]                 names <- names(envs)
[01:29:30.507]                 common <- intersect(names, old_names)
[01:29:30.507]                 added <- setdiff(names, old_names)
[01:29:30.507]                 removed <- setdiff(old_names, names)
[01:29:30.507]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:30.507]                   envs[common]]
[01:29:30.507]                 NAMES <- toupper(changed)
[01:29:30.507]                 args <- list()
[01:29:30.507]                 for (kk in seq_along(NAMES)) {
[01:29:30.507]                   name <- changed[[kk]]
[01:29:30.507]                   NAME <- NAMES[[kk]]
[01:29:30.507]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.507]                     next
[01:29:30.507]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.507]                 }
[01:29:30.507]                 NAMES <- toupper(added)
[01:29:30.507]                 for (kk in seq_along(NAMES)) {
[01:29:30.507]                   name <- added[[kk]]
[01:29:30.507]                   NAME <- NAMES[[kk]]
[01:29:30.507]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.507]                     next
[01:29:30.507]                   args[[name]] <- ""
[01:29:30.507]                 }
[01:29:30.507]                 NAMES <- toupper(removed)
[01:29:30.507]                 for (kk in seq_along(NAMES)) {
[01:29:30.507]                   name <- removed[[kk]]
[01:29:30.507]                   NAME <- NAMES[[kk]]
[01:29:30.507]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.507]                     next
[01:29:30.507]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.507]                 }
[01:29:30.507]                 if (length(args) > 0) 
[01:29:30.507]                   base::do.call(base::Sys.setenv, args = args)
[01:29:30.507]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:30.507]             }
[01:29:30.507]             else {
[01:29:30.507]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:30.507]             }
[01:29:30.507]             {
[01:29:30.507]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:30.507]                   0L) {
[01:29:30.507]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:30.507]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:30.507]                   base::options(opts)
[01:29:30.507]                 }
[01:29:30.507]                 {
[01:29:30.507]                   {
[01:29:30.507]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:30.507]                     NULL
[01:29:30.507]                   }
[01:29:30.507]                   options(future.plan = NULL)
[01:29:30.507]                   if (is.na(NA_character_)) 
[01:29:30.507]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.507]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:30.507]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:30.507]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:30.507]                     envir = parent.frame()) 
[01:29:30.507]                   {
[01:29:30.507]                     if (is.function(workers)) 
[01:29:30.507]                       workers <- workers()
[01:29:30.507]                     workers <- structure(as.integer(workers), 
[01:29:30.507]                       class = class(workers))
[01:29:30.507]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:30.507]                       workers >= 1)
[01:29:30.507]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:30.507]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:30.507]                     }
[01:29:30.507]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:30.507]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:30.507]                       envir = envir)
[01:29:30.507]                     if (!future$lazy) 
[01:29:30.507]                       future <- run(future)
[01:29:30.507]                     invisible(future)
[01:29:30.507]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:30.507]                 }
[01:29:30.507]             }
[01:29:30.507]         }
[01:29:30.507]     })
[01:29:30.507]     if (TRUE) {
[01:29:30.507]         base::sink(type = "output", split = FALSE)
[01:29:30.507]         if (TRUE) {
[01:29:30.507]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:30.507]         }
[01:29:30.507]         else {
[01:29:30.507]             ...future.result["stdout"] <- base::list(NULL)
[01:29:30.507]         }
[01:29:30.507]         base::close(...future.stdout)
[01:29:30.507]         ...future.stdout <- NULL
[01:29:30.507]     }
[01:29:30.507]     ...future.result$conditions <- ...future.conditions
[01:29:30.507]     ...future.result$finished <- base::Sys.time()
[01:29:30.507]     ...future.result
[01:29:30.507] }
[01:29:30.513] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:30.513] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:30.514] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:30.514] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:30.515] MultisessionFuture started
[01:29:30.515] - Launch lazy future ... done
[01:29:30.515] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_3-446751'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96d8755a8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[01:29:30.530] receiveMessageFromWorker() for ClusterFuture ...
[01:29:30.530] - Validating connection of MultisessionFuture
[01:29:30.531] - received message: FutureResult
[01:29:30.531] - Received FutureResult
[01:29:30.531] - Erased future from FutureRegistry
[01:29:30.531] result() for ClusterFuture ...
[01:29:30.531] - result already collected: FutureResult
[01:29:30.532] result() for ClusterFuture ... done
[01:29:30.532] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.532] getGlobalsAndPackages() ...
[01:29:30.532] Searching for globals...
[01:29:30.533] - globals found: [3] '{', 'sample', 'x'
[01:29:30.534] Searching for globals ... DONE
[01:29:30.534] Resolving globals: FALSE
[01:29:30.534] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:30.535] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:30.535] - globals: [1] 'x'
[01:29:30.535] 
[01:29:30.535] getGlobalsAndPackages() ... DONE
[01:29:30.536] run() for 'Future' ...
[01:29:30.536] - state: 'created'
[01:29:30.536] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:30.550] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.551] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:30.551]   - Field: 'node'
[01:29:30.551]   - Field: 'label'
[01:29:30.551]   - Field: 'local'
[01:29:30.551]   - Field: 'owner'
[01:29:30.552]   - Field: 'envir'
[01:29:30.552]   - Field: 'workers'
[01:29:30.552]   - Field: 'packages'
[01:29:30.552]   - Field: 'gc'
[01:29:30.552]   - Field: 'conditions'
[01:29:30.552]   - Field: 'persistent'
[01:29:30.553]   - Field: 'expr'
[01:29:30.553]   - Field: 'uuid'
[01:29:30.553]   - Field: 'seed'
[01:29:30.553]   - Field: 'version'
[01:29:30.553]   - Field: 'result'
[01:29:30.553]   - Field: 'asynchronous'
[01:29:30.554]   - Field: 'calls'
[01:29:30.554]   - Field: 'globals'
[01:29:30.554]   - Field: 'stdout'
[01:29:30.554]   - Field: 'earlySignal'
[01:29:30.554]   - Field: 'lazy'
[01:29:30.555]   - Field: 'state'
[01:29:30.555] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:30.555] - Launch lazy future ...
[01:29:30.555] Packages needed by the future expression (n = 0): <none>
[01:29:30.555] Packages needed by future strategies (n = 0): <none>
[01:29:30.556] {
[01:29:30.556]     {
[01:29:30.556]         {
[01:29:30.556]             ...future.startTime <- base::Sys.time()
[01:29:30.556]             {
[01:29:30.556]                 {
[01:29:30.556]                   {
[01:29:30.556]                     {
[01:29:30.556]                       base::local({
[01:29:30.556]                         has_future <- base::requireNamespace("future", 
[01:29:30.556]                           quietly = TRUE)
[01:29:30.556]                         if (has_future) {
[01:29:30.556]                           ns <- base::getNamespace("future")
[01:29:30.556]                           version <- ns[[".package"]][["version"]]
[01:29:30.556]                           if (is.null(version)) 
[01:29:30.556]                             version <- utils::packageVersion("future")
[01:29:30.556]                         }
[01:29:30.556]                         else {
[01:29:30.556]                           version <- NULL
[01:29:30.556]                         }
[01:29:30.556]                         if (!has_future || version < "1.8.0") {
[01:29:30.556]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:30.556]                             "", base::R.version$version.string), 
[01:29:30.556]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:30.556]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:30.556]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:30.556]                               "release", "version")], collapse = " "), 
[01:29:30.556]                             hostname = base::Sys.info()[["nodename"]])
[01:29:30.556]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:30.556]                             info)
[01:29:30.556]                           info <- base::paste(info, collapse = "; ")
[01:29:30.556]                           if (!has_future) {
[01:29:30.556]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:30.556]                               info)
[01:29:30.556]                           }
[01:29:30.556]                           else {
[01:29:30.556]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:30.556]                               info, version)
[01:29:30.556]                           }
[01:29:30.556]                           base::stop(msg)
[01:29:30.556]                         }
[01:29:30.556]                       })
[01:29:30.556]                     }
[01:29:30.556]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:30.556]                     base::options(mc.cores = 1L)
[01:29:30.556]                   }
[01:29:30.556]                   options(future.plan = NULL)
[01:29:30.556]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.556]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:30.556]                 }
[01:29:30.556]                 ...future.workdir <- getwd()
[01:29:30.556]             }
[01:29:30.556]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:30.556]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:30.556]         }
[01:29:30.556]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:30.556]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:30.556]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:30.556]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:30.556]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:30.556]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:30.556]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:30.556]             base::names(...future.oldOptions))
[01:29:30.556]     }
[01:29:30.556]     if (FALSE) {
[01:29:30.556]     }
[01:29:30.556]     else {
[01:29:30.556]         if (TRUE) {
[01:29:30.556]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:30.556]                 open = "w")
[01:29:30.556]         }
[01:29:30.556]         else {
[01:29:30.556]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:30.556]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:30.556]         }
[01:29:30.556]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:30.556]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:30.556]             base::sink(type = "output", split = FALSE)
[01:29:30.556]             base::close(...future.stdout)
[01:29:30.556]         }, add = TRUE)
[01:29:30.556]     }
[01:29:30.556]     ...future.frame <- base::sys.nframe()
[01:29:30.556]     ...future.conditions <- base::list()
[01:29:30.556]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:30.556]     if (FALSE) {
[01:29:30.556]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:30.556]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:30.556]     }
[01:29:30.556]     ...future.result <- base::tryCatch({
[01:29:30.556]         base::withCallingHandlers({
[01:29:30.556]             ...future.value <- base::withVisible(base::local({
[01:29:30.556]                 ...future.makeSendCondition <- base::local({
[01:29:30.556]                   sendCondition <- NULL
[01:29:30.556]                   function(frame = 1L) {
[01:29:30.556]                     if (is.function(sendCondition)) 
[01:29:30.556]                       return(sendCondition)
[01:29:30.556]                     ns <- getNamespace("parallel")
[01:29:30.556]                     if (exists("sendData", mode = "function", 
[01:29:30.556]                       envir = ns)) {
[01:29:30.556]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:30.556]                         envir = ns)
[01:29:30.556]                       envir <- sys.frame(frame)
[01:29:30.556]                       master <- NULL
[01:29:30.556]                       while (!identical(envir, .GlobalEnv) && 
[01:29:30.556]                         !identical(envir, emptyenv())) {
[01:29:30.556]                         if (exists("master", mode = "list", envir = envir, 
[01:29:30.556]                           inherits = FALSE)) {
[01:29:30.556]                           master <- get("master", mode = "list", 
[01:29:30.556]                             envir = envir, inherits = FALSE)
[01:29:30.556]                           if (inherits(master, c("SOCKnode", 
[01:29:30.556]                             "SOCK0node"))) {
[01:29:30.556]                             sendCondition <<- function(cond) {
[01:29:30.556]                               data <- list(type = "VALUE", value = cond, 
[01:29:30.556]                                 success = TRUE)
[01:29:30.556]                               parallel_sendData(master, data)
[01:29:30.556]                             }
[01:29:30.556]                             return(sendCondition)
[01:29:30.556]                           }
[01:29:30.556]                         }
[01:29:30.556]                         frame <- frame + 1L
[01:29:30.556]                         envir <- sys.frame(frame)
[01:29:30.556]                       }
[01:29:30.556]                     }
[01:29:30.556]                     sendCondition <<- function(cond) NULL
[01:29:30.556]                   }
[01:29:30.556]                 })
[01:29:30.556]                 withCallingHandlers({
[01:29:30.556]                   {
[01:29:30.556]                     sample(x, size = 1L)
[01:29:30.556]                   }
[01:29:30.556]                 }, immediateCondition = function(cond) {
[01:29:30.556]                   sendCondition <- ...future.makeSendCondition()
[01:29:30.556]                   sendCondition(cond)
[01:29:30.556]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.556]                   {
[01:29:30.556]                     inherits <- base::inherits
[01:29:30.556]                     invokeRestart <- base::invokeRestart
[01:29:30.556]                     is.null <- base::is.null
[01:29:30.556]                     muffled <- FALSE
[01:29:30.556]                     if (inherits(cond, "message")) {
[01:29:30.556]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:30.556]                       if (muffled) 
[01:29:30.556]                         invokeRestart("muffleMessage")
[01:29:30.556]                     }
[01:29:30.556]                     else if (inherits(cond, "warning")) {
[01:29:30.556]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:30.556]                       if (muffled) 
[01:29:30.556]                         invokeRestart("muffleWarning")
[01:29:30.556]                     }
[01:29:30.556]                     else if (inherits(cond, "condition")) {
[01:29:30.556]                       if (!is.null(pattern)) {
[01:29:30.556]                         computeRestarts <- base::computeRestarts
[01:29:30.556]                         grepl <- base::grepl
[01:29:30.556]                         restarts <- computeRestarts(cond)
[01:29:30.556]                         for (restart in restarts) {
[01:29:30.556]                           name <- restart$name
[01:29:30.556]                           if (is.null(name)) 
[01:29:30.556]                             next
[01:29:30.556]                           if (!grepl(pattern, name)) 
[01:29:30.556]                             next
[01:29:30.556]                           invokeRestart(restart)
[01:29:30.556]                           muffled <- TRUE
[01:29:30.556]                           break
[01:29:30.556]                         }
[01:29:30.556]                       }
[01:29:30.556]                     }
[01:29:30.556]                     invisible(muffled)
[01:29:30.556]                   }
[01:29:30.556]                   muffleCondition(cond)
[01:29:30.556]                 })
[01:29:30.556]             }))
[01:29:30.556]             future::FutureResult(value = ...future.value$value, 
[01:29:30.556]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.556]                   ...future.rng), globalenv = if (FALSE) 
[01:29:30.556]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:30.556]                     ...future.globalenv.names))
[01:29:30.556]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:30.556]         }, condition = base::local({
[01:29:30.556]             c <- base::c
[01:29:30.556]             inherits <- base::inherits
[01:29:30.556]             invokeRestart <- base::invokeRestart
[01:29:30.556]             length <- base::length
[01:29:30.556]             list <- base::list
[01:29:30.556]             seq.int <- base::seq.int
[01:29:30.556]             signalCondition <- base::signalCondition
[01:29:30.556]             sys.calls <- base::sys.calls
[01:29:30.556]             `[[` <- base::`[[`
[01:29:30.556]             `+` <- base::`+`
[01:29:30.556]             `<<-` <- base::`<<-`
[01:29:30.556]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:30.556]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:30.556]                   3L)]
[01:29:30.556]             }
[01:29:30.556]             function(cond) {
[01:29:30.556]                 is_error <- inherits(cond, "error")
[01:29:30.556]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:30.556]                   NULL)
[01:29:30.556]                 if (is_error) {
[01:29:30.556]                   sessionInformation <- function() {
[01:29:30.556]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:30.556]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:30.556]                       search = base::search(), system = base::Sys.info())
[01:29:30.556]                   }
[01:29:30.556]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.556]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:30.556]                     cond$call), session = sessionInformation(), 
[01:29:30.556]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:30.556]                   signalCondition(cond)
[01:29:30.556]                 }
[01:29:30.556]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:30.556]                 "immediateCondition"))) {
[01:29:30.556]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:30.556]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.556]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:30.556]                   if (TRUE && !signal) {
[01:29:30.556]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.556]                     {
[01:29:30.556]                       inherits <- base::inherits
[01:29:30.556]                       invokeRestart <- base::invokeRestart
[01:29:30.556]                       is.null <- base::is.null
[01:29:30.556]                       muffled <- FALSE
[01:29:30.556]                       if (inherits(cond, "message")) {
[01:29:30.556]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.556]                         if (muffled) 
[01:29:30.556]                           invokeRestart("muffleMessage")
[01:29:30.556]                       }
[01:29:30.556]                       else if (inherits(cond, "warning")) {
[01:29:30.556]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.556]                         if (muffled) 
[01:29:30.556]                           invokeRestart("muffleWarning")
[01:29:30.556]                       }
[01:29:30.556]                       else if (inherits(cond, "condition")) {
[01:29:30.556]                         if (!is.null(pattern)) {
[01:29:30.556]                           computeRestarts <- base::computeRestarts
[01:29:30.556]                           grepl <- base::grepl
[01:29:30.556]                           restarts <- computeRestarts(cond)
[01:29:30.556]                           for (restart in restarts) {
[01:29:30.556]                             name <- restart$name
[01:29:30.556]                             if (is.null(name)) 
[01:29:30.556]                               next
[01:29:30.556]                             if (!grepl(pattern, name)) 
[01:29:30.556]                               next
[01:29:30.556]                             invokeRestart(restart)
[01:29:30.556]                             muffled <- TRUE
[01:29:30.556]                             break
[01:29:30.556]                           }
[01:29:30.556]                         }
[01:29:30.556]                       }
[01:29:30.556]                       invisible(muffled)
[01:29:30.556]                     }
[01:29:30.556]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.556]                   }
[01:29:30.556]                 }
[01:29:30.556]                 else {
[01:29:30.556]                   if (TRUE) {
[01:29:30.556]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.556]                     {
[01:29:30.556]                       inherits <- base::inherits
[01:29:30.556]                       invokeRestart <- base::invokeRestart
[01:29:30.556]                       is.null <- base::is.null
[01:29:30.556]                       muffled <- FALSE
[01:29:30.556]                       if (inherits(cond, "message")) {
[01:29:30.556]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.556]                         if (muffled) 
[01:29:30.556]                           invokeRestart("muffleMessage")
[01:29:30.556]                       }
[01:29:30.556]                       else if (inherits(cond, "warning")) {
[01:29:30.556]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.556]                         if (muffled) 
[01:29:30.556]                           invokeRestart("muffleWarning")
[01:29:30.556]                       }
[01:29:30.556]                       else if (inherits(cond, "condition")) {
[01:29:30.556]                         if (!is.null(pattern)) {
[01:29:30.556]                           computeRestarts <- base::computeRestarts
[01:29:30.556]                           grepl <- base::grepl
[01:29:30.556]                           restarts <- computeRestarts(cond)
[01:29:30.556]                           for (restart in restarts) {
[01:29:30.556]                             name <- restart$name
[01:29:30.556]                             if (is.null(name)) 
[01:29:30.556]                               next
[01:29:30.556]                             if (!grepl(pattern, name)) 
[01:29:30.556]                               next
[01:29:30.556]                             invokeRestart(restart)
[01:29:30.556]                             muffled <- TRUE
[01:29:30.556]                             break
[01:29:30.556]                           }
[01:29:30.556]                         }
[01:29:30.556]                       }
[01:29:30.556]                       invisible(muffled)
[01:29:30.556]                     }
[01:29:30.556]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.556]                   }
[01:29:30.556]                 }
[01:29:30.556]             }
[01:29:30.556]         }))
[01:29:30.556]     }, error = function(ex) {
[01:29:30.556]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:30.556]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.556]                 ...future.rng), started = ...future.startTime, 
[01:29:30.556]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:30.556]             version = "1.8"), class = "FutureResult")
[01:29:30.556]     }, finally = {
[01:29:30.556]         if (!identical(...future.workdir, getwd())) 
[01:29:30.556]             setwd(...future.workdir)
[01:29:30.556]         {
[01:29:30.556]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:30.556]                 ...future.oldOptions$nwarnings <- NULL
[01:29:30.556]             }
[01:29:30.556]             base::options(...future.oldOptions)
[01:29:30.556]             if (.Platform$OS.type == "windows") {
[01:29:30.556]                 old_names <- names(...future.oldEnvVars)
[01:29:30.556]                 envs <- base::Sys.getenv()
[01:29:30.556]                 names <- names(envs)
[01:29:30.556]                 common <- intersect(names, old_names)
[01:29:30.556]                 added <- setdiff(names, old_names)
[01:29:30.556]                 removed <- setdiff(old_names, names)
[01:29:30.556]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:30.556]                   envs[common]]
[01:29:30.556]                 NAMES <- toupper(changed)
[01:29:30.556]                 args <- list()
[01:29:30.556]                 for (kk in seq_along(NAMES)) {
[01:29:30.556]                   name <- changed[[kk]]
[01:29:30.556]                   NAME <- NAMES[[kk]]
[01:29:30.556]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.556]                     next
[01:29:30.556]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.556]                 }
[01:29:30.556]                 NAMES <- toupper(added)
[01:29:30.556]                 for (kk in seq_along(NAMES)) {
[01:29:30.556]                   name <- added[[kk]]
[01:29:30.556]                   NAME <- NAMES[[kk]]
[01:29:30.556]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.556]                     next
[01:29:30.556]                   args[[name]] <- ""
[01:29:30.556]                 }
[01:29:30.556]                 NAMES <- toupper(removed)
[01:29:30.556]                 for (kk in seq_along(NAMES)) {
[01:29:30.556]                   name <- removed[[kk]]
[01:29:30.556]                   NAME <- NAMES[[kk]]
[01:29:30.556]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.556]                     next
[01:29:30.556]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.556]                 }
[01:29:30.556]                 if (length(args) > 0) 
[01:29:30.556]                   base::do.call(base::Sys.setenv, args = args)
[01:29:30.556]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:30.556]             }
[01:29:30.556]             else {
[01:29:30.556]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:30.556]             }
[01:29:30.556]             {
[01:29:30.556]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:30.556]                   0L) {
[01:29:30.556]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:30.556]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:30.556]                   base::options(opts)
[01:29:30.556]                 }
[01:29:30.556]                 {
[01:29:30.556]                   {
[01:29:30.556]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:30.556]                     NULL
[01:29:30.556]                   }
[01:29:30.556]                   options(future.plan = NULL)
[01:29:30.556]                   if (is.na(NA_character_)) 
[01:29:30.556]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.556]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:30.556]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:30.556]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:30.556]                     envir = parent.frame()) 
[01:29:30.556]                   {
[01:29:30.556]                     if (is.function(workers)) 
[01:29:30.556]                       workers <- workers()
[01:29:30.556]                     workers <- structure(as.integer(workers), 
[01:29:30.556]                       class = class(workers))
[01:29:30.556]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:30.556]                       workers >= 1)
[01:29:30.556]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:30.556]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:30.556]                     }
[01:29:30.556]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:30.556]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:30.556]                       envir = envir)
[01:29:30.556]                     if (!future$lazy) 
[01:29:30.556]                       future <- run(future)
[01:29:30.556]                     invisible(future)
[01:29:30.556]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:30.556]                 }
[01:29:30.556]             }
[01:29:30.556]         }
[01:29:30.556]     })
[01:29:30.556]     if (TRUE) {
[01:29:30.556]         base::sink(type = "output", split = FALSE)
[01:29:30.556]         if (TRUE) {
[01:29:30.556]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:30.556]         }
[01:29:30.556]         else {
[01:29:30.556]             ...future.result["stdout"] <- base::list(NULL)
[01:29:30.556]         }
[01:29:30.556]         base::close(...future.stdout)
[01:29:30.556]         ...future.stdout <- NULL
[01:29:30.556]     }
[01:29:30.556]     ...future.result$conditions <- ...future.conditions
[01:29:30.556]     ...future.result$finished <- base::Sys.time()
[01:29:30.556]     ...future.result
[01:29:30.556] }
[01:29:30.562] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:30.562] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:30.562] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:30.563] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:30.563] MultisessionFuture started
[01:29:30.563] - Launch lazy future ... done
[01:29:30.564] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_4-492830'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96d8755a8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[01:29:30.580] receiveMessageFromWorker() for ClusterFuture ...
[01:29:30.580] - Validating connection of MultisessionFuture
[01:29:30.583] - received message: FutureResult
[01:29:30.584] - Received FutureResult
[01:29:30.584] - Erased future from FutureRegistry
[01:29:30.584] result() for ClusterFuture ...
[01:29:30.584] - result already collected: FutureResult
[01:29:30.584] result() for ClusterFuture ... done
[01:29:30.585] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.585] resolve() on list ...
[01:29:30.585]  recursive: 0
[01:29:30.585]  length: 4
[01:29:30.585] 
[01:29:30.586] Future #1
[01:29:30.586] result() for ClusterFuture ...
[01:29:30.586] - result already collected: FutureResult
[01:29:30.586] result() for ClusterFuture ... done
[01:29:30.586] result() for ClusterFuture ...
[01:29:30.586] - result already collected: FutureResult
[01:29:30.587] result() for ClusterFuture ... done
[01:29:30.587] signalConditionsASAP(MultisessionFuture, pos=1) ...
[01:29:30.587] - nx: 4
[01:29:30.587] - relay: TRUE
[01:29:30.587] - stdout: TRUE
[01:29:30.587] - signal: TRUE
[01:29:30.588] - resignal: FALSE
[01:29:30.588] - force: TRUE
[01:29:30.588] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:30.588] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:30.588]  - until=1
[01:29:30.588]  - relaying element #1
[01:29:30.589] result() for ClusterFuture ...
[01:29:30.589] - result already collected: FutureResult
[01:29:30.589] result() for ClusterFuture ... done
[01:29:30.589] result() for ClusterFuture ...
[01:29:30.589] - result already collected: FutureResult
[01:29:30.589] result() for ClusterFuture ... done
[01:29:30.590] result() for ClusterFuture ...
[01:29:30.590] - result already collected: FutureResult
[01:29:30.590] result() for ClusterFuture ... done
[01:29:30.590] result() for ClusterFuture ...
[01:29:30.590] - result already collected: FutureResult
[01:29:30.590] result() for ClusterFuture ... done
[01:29:30.591] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:30.591] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:30.591] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[01:29:30.591]  length: 3 (resolved future 1)
[01:29:30.591] Future #2
[01:29:30.591] result() for ClusterFuture ...
[01:29:30.592] - result already collected: FutureResult
[01:29:30.592] result() for ClusterFuture ... done
[01:29:30.592] result() for ClusterFuture ...
[01:29:30.592] - result already collected: FutureResult
[01:29:30.592] result() for ClusterFuture ... done
[01:29:30.592] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:29:30.593] - nx: 4
[01:29:30.593] - relay: TRUE
[01:29:30.593] - stdout: TRUE
[01:29:30.593] - signal: TRUE
[01:29:30.593] - resignal: FALSE
[01:29:30.593] - force: TRUE
[01:29:30.593] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:30.594] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:30.594]  - until=2
[01:29:30.594]  - relaying element #2
[01:29:30.594] result() for ClusterFuture ...
[01:29:30.594] - result already collected: FutureResult
[01:29:30.594] result() for ClusterFuture ... done
[01:29:30.595] result() for ClusterFuture ...
[01:29:30.595] - result already collected: FutureResult
[01:29:30.595] result() for ClusterFuture ... done
[01:29:30.595] result() for ClusterFuture ...
[01:29:30.595] - result already collected: FutureResult
[01:29:30.595] result() for ClusterFuture ... done
[01:29:30.596] result() for ClusterFuture ...
[01:29:30.596] - result already collected: FutureResult
[01:29:30.596] result() for ClusterFuture ... done
[01:29:30.596] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:30.596] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:30.596] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:29:30.597]  length: 2 (resolved future 2)
[01:29:30.597] Future #3
[01:29:30.597] result() for ClusterFuture ...
[01:29:30.597] - result already collected: FutureResult
[01:29:30.597] result() for ClusterFuture ... done
[01:29:30.597] result() for ClusterFuture ...
[01:29:30.598] - result already collected: FutureResult
[01:29:30.598] result() for ClusterFuture ... done
[01:29:30.598] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:29:30.598] - nx: 4
[01:29:30.598] - relay: TRUE
[01:29:30.598] - stdout: TRUE
[01:29:30.599] - signal: TRUE
[01:29:30.599] - resignal: FALSE
[01:29:30.599] - force: TRUE
[01:29:30.599] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:30.599] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:30.599]  - until=3
[01:29:30.599]  - relaying element #3
[01:29:30.600] result() for ClusterFuture ...
[01:29:30.600] - result already collected: FutureResult
[01:29:30.600] result() for ClusterFuture ... done
[01:29:30.600] result() for ClusterFuture ...
[01:29:30.600] - result already collected: FutureResult
[01:29:30.600] result() for ClusterFuture ... done
[01:29:30.601] result() for ClusterFuture ...
[01:29:30.601] - result already collected: FutureResult
[01:29:30.601] result() for ClusterFuture ... done
[01:29:30.601] result() for ClusterFuture ...
[01:29:30.601] - result already collected: FutureResult
[01:29:30.601] result() for ClusterFuture ... done
[01:29:30.602] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:30.602] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:30.602] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:29:30.602]  length: 1 (resolved future 3)
[01:29:30.602] Future #4
[01:29:30.602] result() for ClusterFuture ...
[01:29:30.603] - result already collected: FutureResult
[01:29:30.603] result() for ClusterFuture ... done
[01:29:30.603] result() for ClusterFuture ...
[01:29:30.603] - result already collected: FutureResult
[01:29:30.603] result() for ClusterFuture ... done
[01:29:30.603] signalConditionsASAP(MultisessionFuture, pos=4) ...
[01:29:30.604] - nx: 4
[01:29:30.604] - relay: TRUE
[01:29:30.604] - stdout: TRUE
[01:29:30.604] - signal: TRUE
[01:29:30.604] - resignal: FALSE
[01:29:30.604] - force: TRUE
[01:29:30.605] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:30.605] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:30.605]  - until=4
[01:29:30.605]  - relaying element #4
[01:29:30.605] result() for ClusterFuture ...
[01:29:30.605] - result already collected: FutureResult
[01:29:30.606] result() for ClusterFuture ... done
[01:29:30.606] result() for ClusterFuture ...
[01:29:30.606] - result already collected: FutureResult
[01:29:30.606] result() for ClusterFuture ... done
[01:29:30.606] result() for ClusterFuture ...
[01:29:30.607] - result already collected: FutureResult
[01:29:30.607] result() for ClusterFuture ... done
[01:29:30.607] result() for ClusterFuture ...
[01:29:30.607] - result already collected: FutureResult
[01:29:30.607] result() for ClusterFuture ... done
[01:29:30.607] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:30.608] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:30.608] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[01:29:30.608]  length: 0 (resolved future 4)
[01:29:30.608] Relaying remaining futures
[01:29:30.608] signalConditionsASAP(NULL, pos=0) ...
[01:29:30.609] - nx: 4
[01:29:30.609] - relay: TRUE
[01:29:30.609] - stdout: TRUE
[01:29:30.609] - signal: TRUE
[01:29:30.609] - resignal: FALSE
[01:29:30.609] - force: TRUE
[01:29:30.610] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:30.610] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[01:29:30.610] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:30.610] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:30.610] signalConditionsASAP(NULL, pos=0) ... done
[01:29:30.610] resolve() on list ... DONE
[01:29:30.611] result() for ClusterFuture ...
[01:29:30.611] - result already collected: FutureResult
[01:29:30.611] result() for ClusterFuture ... done
[01:29:30.611] result() for ClusterFuture ...
[01:29:30.611] - result already collected: FutureResult
[01:29:30.612] result() for ClusterFuture ... done
[01:29:30.612] result() for ClusterFuture ...
[01:29:30.612] - result already collected: FutureResult
[01:29:30.613] result() for ClusterFuture ... done
[01:29:30.613] result() for ClusterFuture ...
[01:29:30.613] - result already collected: FutureResult
[01:29:30.613] result() for ClusterFuture ... done
[01:29:30.614] result() for ClusterFuture ...
[01:29:30.614] - result already collected: FutureResult
[01:29:30.614] result() for ClusterFuture ... done
[01:29:30.614] result() for ClusterFuture ...
[01:29:30.614] - result already collected: FutureResult
[01:29:30.615] result() for ClusterFuture ... done
[01:29:30.615] result() for ClusterFuture ...
[01:29:30.615] - result already collected: FutureResult
[01:29:30.615] result() for ClusterFuture ... done
[01:29:30.615] result() for ClusterFuture ...
[01:29:30.616] - result already collected: FutureResult
[01:29:30.616] result() for ClusterFuture ... done
[[1]]
[1] 0

[[2]]
[1] 0

[[3]]
[1] 2

[[4]]
[1] 1

[01:29:30.616] getGlobalsAndPackages() ...
[01:29:30.617] Searching for globals...
[01:29:30.619] - globals found: [3] '{', 'sample', 'x'
[01:29:30.619] Searching for globals ... DONE
[01:29:30.619] Resolving globals: FALSE
[01:29:30.620] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:30.621] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:30.621] - globals: [1] 'x'
[01:29:30.622] 
[01:29:30.622] getGlobalsAndPackages() ... DONE
[01:29:30.622] run() for 'Future' ...
[01:29:30.622] - state: 'created'
[01:29:30.623] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:30.640] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.640] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:30.641]   - Field: 'node'
[01:29:30.641]   - Field: 'label'
[01:29:30.641]   - Field: 'local'
[01:29:30.641]   - Field: 'owner'
[01:29:30.641]   - Field: 'envir'
[01:29:30.642]   - Field: 'workers'
[01:29:30.642]   - Field: 'packages'
[01:29:30.642]   - Field: 'gc'
[01:29:30.642]   - Field: 'conditions'
[01:29:30.643]   - Field: 'persistent'
[01:29:30.643]   - Field: 'expr'
[01:29:30.643]   - Field: 'uuid'
[01:29:30.643]   - Field: 'seed'
[01:29:30.643]   - Field: 'version'
[01:29:30.644]   - Field: 'result'
[01:29:30.644]   - Field: 'asynchronous'
[01:29:30.644]   - Field: 'calls'
[01:29:30.644]   - Field: 'globals'
[01:29:30.644]   - Field: 'stdout'
[01:29:30.645]   - Field: 'earlySignal'
[01:29:30.645]   - Field: 'lazy'
[01:29:30.645]   - Field: 'state'
[01:29:30.645] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:30.645] - Launch lazy future ...
[01:29:30.646] Packages needed by the future expression (n = 0): <none>
[01:29:30.646] Packages needed by future strategies (n = 0): <none>
[01:29:30.647] {
[01:29:30.647]     {
[01:29:30.647]         {
[01:29:30.647]             ...future.startTime <- base::Sys.time()
[01:29:30.647]             {
[01:29:30.647]                 {
[01:29:30.647]                   {
[01:29:30.647]                     {
[01:29:30.647]                       base::local({
[01:29:30.647]                         has_future <- base::requireNamespace("future", 
[01:29:30.647]                           quietly = TRUE)
[01:29:30.647]                         if (has_future) {
[01:29:30.647]                           ns <- base::getNamespace("future")
[01:29:30.647]                           version <- ns[[".package"]][["version"]]
[01:29:30.647]                           if (is.null(version)) 
[01:29:30.647]                             version <- utils::packageVersion("future")
[01:29:30.647]                         }
[01:29:30.647]                         else {
[01:29:30.647]                           version <- NULL
[01:29:30.647]                         }
[01:29:30.647]                         if (!has_future || version < "1.8.0") {
[01:29:30.647]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:30.647]                             "", base::R.version$version.string), 
[01:29:30.647]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:30.647]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:30.647]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:30.647]                               "release", "version")], collapse = " "), 
[01:29:30.647]                             hostname = base::Sys.info()[["nodename"]])
[01:29:30.647]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:30.647]                             info)
[01:29:30.647]                           info <- base::paste(info, collapse = "; ")
[01:29:30.647]                           if (!has_future) {
[01:29:30.647]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:30.647]                               info)
[01:29:30.647]                           }
[01:29:30.647]                           else {
[01:29:30.647]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:30.647]                               info, version)
[01:29:30.647]                           }
[01:29:30.647]                           base::stop(msg)
[01:29:30.647]                         }
[01:29:30.647]                       })
[01:29:30.647]                     }
[01:29:30.647]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:30.647]                     base::options(mc.cores = 1L)
[01:29:30.647]                   }
[01:29:30.647]                   options(future.plan = NULL)
[01:29:30.647]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.647]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:30.647]                 }
[01:29:30.647]                 ...future.workdir <- getwd()
[01:29:30.647]             }
[01:29:30.647]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:30.647]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:30.647]         }
[01:29:30.647]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:30.647]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:30.647]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:30.647]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:30.647]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:30.647]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:30.647]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:30.647]             base::names(...future.oldOptions))
[01:29:30.647]     }
[01:29:30.647]     if (FALSE) {
[01:29:30.647]     }
[01:29:30.647]     else {
[01:29:30.647]         if (TRUE) {
[01:29:30.647]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:30.647]                 open = "w")
[01:29:30.647]         }
[01:29:30.647]         else {
[01:29:30.647]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:30.647]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:30.647]         }
[01:29:30.647]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:30.647]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:30.647]             base::sink(type = "output", split = FALSE)
[01:29:30.647]             base::close(...future.stdout)
[01:29:30.647]         }, add = TRUE)
[01:29:30.647]     }
[01:29:30.647]     ...future.frame <- base::sys.nframe()
[01:29:30.647]     ...future.conditions <- base::list()
[01:29:30.647]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:30.647]     if (FALSE) {
[01:29:30.647]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:30.647]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:30.647]     }
[01:29:30.647]     ...future.result <- base::tryCatch({
[01:29:30.647]         base::withCallingHandlers({
[01:29:30.647]             ...future.value <- base::withVisible(base::local({
[01:29:30.647]                 ...future.makeSendCondition <- base::local({
[01:29:30.647]                   sendCondition <- NULL
[01:29:30.647]                   function(frame = 1L) {
[01:29:30.647]                     if (is.function(sendCondition)) 
[01:29:30.647]                       return(sendCondition)
[01:29:30.647]                     ns <- getNamespace("parallel")
[01:29:30.647]                     if (exists("sendData", mode = "function", 
[01:29:30.647]                       envir = ns)) {
[01:29:30.647]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:30.647]                         envir = ns)
[01:29:30.647]                       envir <- sys.frame(frame)
[01:29:30.647]                       master <- NULL
[01:29:30.647]                       while (!identical(envir, .GlobalEnv) && 
[01:29:30.647]                         !identical(envir, emptyenv())) {
[01:29:30.647]                         if (exists("master", mode = "list", envir = envir, 
[01:29:30.647]                           inherits = FALSE)) {
[01:29:30.647]                           master <- get("master", mode = "list", 
[01:29:30.647]                             envir = envir, inherits = FALSE)
[01:29:30.647]                           if (inherits(master, c("SOCKnode", 
[01:29:30.647]                             "SOCK0node"))) {
[01:29:30.647]                             sendCondition <<- function(cond) {
[01:29:30.647]                               data <- list(type = "VALUE", value = cond, 
[01:29:30.647]                                 success = TRUE)
[01:29:30.647]                               parallel_sendData(master, data)
[01:29:30.647]                             }
[01:29:30.647]                             return(sendCondition)
[01:29:30.647]                           }
[01:29:30.647]                         }
[01:29:30.647]                         frame <- frame + 1L
[01:29:30.647]                         envir <- sys.frame(frame)
[01:29:30.647]                       }
[01:29:30.647]                     }
[01:29:30.647]                     sendCondition <<- function(cond) NULL
[01:29:30.647]                   }
[01:29:30.647]                 })
[01:29:30.647]                 withCallingHandlers({
[01:29:30.647]                   {
[01:29:30.647]                     sample(x, size = 1L)
[01:29:30.647]                   }
[01:29:30.647]                 }, immediateCondition = function(cond) {
[01:29:30.647]                   sendCondition <- ...future.makeSendCondition()
[01:29:30.647]                   sendCondition(cond)
[01:29:30.647]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.647]                   {
[01:29:30.647]                     inherits <- base::inherits
[01:29:30.647]                     invokeRestart <- base::invokeRestart
[01:29:30.647]                     is.null <- base::is.null
[01:29:30.647]                     muffled <- FALSE
[01:29:30.647]                     if (inherits(cond, "message")) {
[01:29:30.647]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:30.647]                       if (muffled) 
[01:29:30.647]                         invokeRestart("muffleMessage")
[01:29:30.647]                     }
[01:29:30.647]                     else if (inherits(cond, "warning")) {
[01:29:30.647]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:30.647]                       if (muffled) 
[01:29:30.647]                         invokeRestart("muffleWarning")
[01:29:30.647]                     }
[01:29:30.647]                     else if (inherits(cond, "condition")) {
[01:29:30.647]                       if (!is.null(pattern)) {
[01:29:30.647]                         computeRestarts <- base::computeRestarts
[01:29:30.647]                         grepl <- base::grepl
[01:29:30.647]                         restarts <- computeRestarts(cond)
[01:29:30.647]                         for (restart in restarts) {
[01:29:30.647]                           name <- restart$name
[01:29:30.647]                           if (is.null(name)) 
[01:29:30.647]                             next
[01:29:30.647]                           if (!grepl(pattern, name)) 
[01:29:30.647]                             next
[01:29:30.647]                           invokeRestart(restart)
[01:29:30.647]                           muffled <- TRUE
[01:29:30.647]                           break
[01:29:30.647]                         }
[01:29:30.647]                       }
[01:29:30.647]                     }
[01:29:30.647]                     invisible(muffled)
[01:29:30.647]                   }
[01:29:30.647]                   muffleCondition(cond)
[01:29:30.647]                 })
[01:29:30.647]             }))
[01:29:30.647]             future::FutureResult(value = ...future.value$value, 
[01:29:30.647]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.647]                   ...future.rng), globalenv = if (FALSE) 
[01:29:30.647]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:30.647]                     ...future.globalenv.names))
[01:29:30.647]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:30.647]         }, condition = base::local({
[01:29:30.647]             c <- base::c
[01:29:30.647]             inherits <- base::inherits
[01:29:30.647]             invokeRestart <- base::invokeRestart
[01:29:30.647]             length <- base::length
[01:29:30.647]             list <- base::list
[01:29:30.647]             seq.int <- base::seq.int
[01:29:30.647]             signalCondition <- base::signalCondition
[01:29:30.647]             sys.calls <- base::sys.calls
[01:29:30.647]             `[[` <- base::`[[`
[01:29:30.647]             `+` <- base::`+`
[01:29:30.647]             `<<-` <- base::`<<-`
[01:29:30.647]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:30.647]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:30.647]                   3L)]
[01:29:30.647]             }
[01:29:30.647]             function(cond) {
[01:29:30.647]                 is_error <- inherits(cond, "error")
[01:29:30.647]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:30.647]                   NULL)
[01:29:30.647]                 if (is_error) {
[01:29:30.647]                   sessionInformation <- function() {
[01:29:30.647]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:30.647]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:30.647]                       search = base::search(), system = base::Sys.info())
[01:29:30.647]                   }
[01:29:30.647]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.647]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:30.647]                     cond$call), session = sessionInformation(), 
[01:29:30.647]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:30.647]                   signalCondition(cond)
[01:29:30.647]                 }
[01:29:30.647]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:30.647]                 "immediateCondition"))) {
[01:29:30.647]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:30.647]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.647]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:30.647]                   if (TRUE && !signal) {
[01:29:30.647]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.647]                     {
[01:29:30.647]                       inherits <- base::inherits
[01:29:30.647]                       invokeRestart <- base::invokeRestart
[01:29:30.647]                       is.null <- base::is.null
[01:29:30.647]                       muffled <- FALSE
[01:29:30.647]                       if (inherits(cond, "message")) {
[01:29:30.647]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.647]                         if (muffled) 
[01:29:30.647]                           invokeRestart("muffleMessage")
[01:29:30.647]                       }
[01:29:30.647]                       else if (inherits(cond, "warning")) {
[01:29:30.647]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.647]                         if (muffled) 
[01:29:30.647]                           invokeRestart("muffleWarning")
[01:29:30.647]                       }
[01:29:30.647]                       else if (inherits(cond, "condition")) {
[01:29:30.647]                         if (!is.null(pattern)) {
[01:29:30.647]                           computeRestarts <- base::computeRestarts
[01:29:30.647]                           grepl <- base::grepl
[01:29:30.647]                           restarts <- computeRestarts(cond)
[01:29:30.647]                           for (restart in restarts) {
[01:29:30.647]                             name <- restart$name
[01:29:30.647]                             if (is.null(name)) 
[01:29:30.647]                               next
[01:29:30.647]                             if (!grepl(pattern, name)) 
[01:29:30.647]                               next
[01:29:30.647]                             invokeRestart(restart)
[01:29:30.647]                             muffled <- TRUE
[01:29:30.647]                             break
[01:29:30.647]                           }
[01:29:30.647]                         }
[01:29:30.647]                       }
[01:29:30.647]                       invisible(muffled)
[01:29:30.647]                     }
[01:29:30.647]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.647]                   }
[01:29:30.647]                 }
[01:29:30.647]                 else {
[01:29:30.647]                   if (TRUE) {
[01:29:30.647]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.647]                     {
[01:29:30.647]                       inherits <- base::inherits
[01:29:30.647]                       invokeRestart <- base::invokeRestart
[01:29:30.647]                       is.null <- base::is.null
[01:29:30.647]                       muffled <- FALSE
[01:29:30.647]                       if (inherits(cond, "message")) {
[01:29:30.647]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.647]                         if (muffled) 
[01:29:30.647]                           invokeRestart("muffleMessage")
[01:29:30.647]                       }
[01:29:30.647]                       else if (inherits(cond, "warning")) {
[01:29:30.647]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.647]                         if (muffled) 
[01:29:30.647]                           invokeRestart("muffleWarning")
[01:29:30.647]                       }
[01:29:30.647]                       else if (inherits(cond, "condition")) {
[01:29:30.647]                         if (!is.null(pattern)) {
[01:29:30.647]                           computeRestarts <- base::computeRestarts
[01:29:30.647]                           grepl <- base::grepl
[01:29:30.647]                           restarts <- computeRestarts(cond)
[01:29:30.647]                           for (restart in restarts) {
[01:29:30.647]                             name <- restart$name
[01:29:30.647]                             if (is.null(name)) 
[01:29:30.647]                               next
[01:29:30.647]                             if (!grepl(pattern, name)) 
[01:29:30.647]                               next
[01:29:30.647]                             invokeRestart(restart)
[01:29:30.647]                             muffled <- TRUE
[01:29:30.647]                             break
[01:29:30.647]                           }
[01:29:30.647]                         }
[01:29:30.647]                       }
[01:29:30.647]                       invisible(muffled)
[01:29:30.647]                     }
[01:29:30.647]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.647]                   }
[01:29:30.647]                 }
[01:29:30.647]             }
[01:29:30.647]         }))
[01:29:30.647]     }, error = function(ex) {
[01:29:30.647]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:30.647]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.647]                 ...future.rng), started = ...future.startTime, 
[01:29:30.647]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:30.647]             version = "1.8"), class = "FutureResult")
[01:29:30.647]     }, finally = {
[01:29:30.647]         if (!identical(...future.workdir, getwd())) 
[01:29:30.647]             setwd(...future.workdir)
[01:29:30.647]         {
[01:29:30.647]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:30.647]                 ...future.oldOptions$nwarnings <- NULL
[01:29:30.647]             }
[01:29:30.647]             base::options(...future.oldOptions)
[01:29:30.647]             if (.Platform$OS.type == "windows") {
[01:29:30.647]                 old_names <- names(...future.oldEnvVars)
[01:29:30.647]                 envs <- base::Sys.getenv()
[01:29:30.647]                 names <- names(envs)
[01:29:30.647]                 common <- intersect(names, old_names)
[01:29:30.647]                 added <- setdiff(names, old_names)
[01:29:30.647]                 removed <- setdiff(old_names, names)
[01:29:30.647]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:30.647]                   envs[common]]
[01:29:30.647]                 NAMES <- toupper(changed)
[01:29:30.647]                 args <- list()
[01:29:30.647]                 for (kk in seq_along(NAMES)) {
[01:29:30.647]                   name <- changed[[kk]]
[01:29:30.647]                   NAME <- NAMES[[kk]]
[01:29:30.647]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.647]                     next
[01:29:30.647]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.647]                 }
[01:29:30.647]                 NAMES <- toupper(added)
[01:29:30.647]                 for (kk in seq_along(NAMES)) {
[01:29:30.647]                   name <- added[[kk]]
[01:29:30.647]                   NAME <- NAMES[[kk]]
[01:29:30.647]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.647]                     next
[01:29:30.647]                   args[[name]] <- ""
[01:29:30.647]                 }
[01:29:30.647]                 NAMES <- toupper(removed)
[01:29:30.647]                 for (kk in seq_along(NAMES)) {
[01:29:30.647]                   name <- removed[[kk]]
[01:29:30.647]                   NAME <- NAMES[[kk]]
[01:29:30.647]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.647]                     next
[01:29:30.647]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.647]                 }
[01:29:30.647]                 if (length(args) > 0) 
[01:29:30.647]                   base::do.call(base::Sys.setenv, args = args)
[01:29:30.647]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:30.647]             }
[01:29:30.647]             else {
[01:29:30.647]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:30.647]             }
[01:29:30.647]             {
[01:29:30.647]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:30.647]                   0L) {
[01:29:30.647]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:30.647]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:30.647]                   base::options(opts)
[01:29:30.647]                 }
[01:29:30.647]                 {
[01:29:30.647]                   {
[01:29:30.647]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:30.647]                     NULL
[01:29:30.647]                   }
[01:29:30.647]                   options(future.plan = NULL)
[01:29:30.647]                   if (is.na(NA_character_)) 
[01:29:30.647]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.647]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:30.647]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:30.647]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:30.647]                     envir = parent.frame()) 
[01:29:30.647]                   {
[01:29:30.647]                     if (is.function(workers)) 
[01:29:30.647]                       workers <- workers()
[01:29:30.647]                     workers <- structure(as.integer(workers), 
[01:29:30.647]                       class = class(workers))
[01:29:30.647]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:30.647]                       workers >= 1)
[01:29:30.647]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:30.647]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:30.647]                     }
[01:29:30.647]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:30.647]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:30.647]                       envir = envir)
[01:29:30.647]                     if (!future$lazy) 
[01:29:30.647]                       future <- run(future)
[01:29:30.647]                     invisible(future)
[01:29:30.647]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:30.647]                 }
[01:29:30.647]             }
[01:29:30.647]         }
[01:29:30.647]     })
[01:29:30.647]     if (TRUE) {
[01:29:30.647]         base::sink(type = "output", split = FALSE)
[01:29:30.647]         if (TRUE) {
[01:29:30.647]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:30.647]         }
[01:29:30.647]         else {
[01:29:30.647]             ...future.result["stdout"] <- base::list(NULL)
[01:29:30.647]         }
[01:29:30.647]         base::close(...future.stdout)
[01:29:30.647]         ...future.stdout <- NULL
[01:29:30.647]     }
[01:29:30.647]     ...future.result$conditions <- ...future.conditions
[01:29:30.647]     ...future.result$finished <- base::Sys.time()
[01:29:30.647]     ...future.result
[01:29:30.647] }
[01:29:30.653] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:30.654] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:30.654] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:30.654] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:30.655] MultisessionFuture started
[01:29:30.656] - Launch lazy future ... done
[01:29:30.656] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_1-682326'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96a7615d8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[01:29:30.672] receiveMessageFromWorker() for ClusterFuture ...
[01:29:30.672] - Validating connection of MultisessionFuture
[01:29:30.673] - received message: FutureResult
[01:29:30.673] - Received FutureResult
[01:29:30.673] - Erased future from FutureRegistry
[01:29:30.673] result() for ClusterFuture ...
[01:29:30.673] - result already collected: FutureResult
[01:29:30.674] result() for ClusterFuture ... done
[01:29:30.674] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.674] getGlobalsAndPackages() ...
[01:29:30.675] Searching for globals...
[01:29:30.676] - globals found: [3] '{', 'sample', 'x'
[01:29:30.676] Searching for globals ... DONE
[01:29:30.677] Resolving globals: FALSE
[01:29:30.677] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:30.678] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:30.678] - globals: [1] 'x'
[01:29:30.678] 
[01:29:30.678] getGlobalsAndPackages() ... DONE
[01:29:30.679] run() for 'Future' ...
[01:29:30.679] - state: 'created'
[01:29:30.679] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:30.695] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.695] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:30.696]   - Field: 'node'
[01:29:30.696]   - Field: 'label'
[01:29:30.696]   - Field: 'local'
[01:29:30.696]   - Field: 'owner'
[01:29:30.697]   - Field: 'envir'
[01:29:30.697]   - Field: 'workers'
[01:29:30.697]   - Field: 'packages'
[01:29:30.697]   - Field: 'gc'
[01:29:30.697]   - Field: 'conditions'
[01:29:30.698]   - Field: 'persistent'
[01:29:30.698]   - Field: 'expr'
[01:29:30.698]   - Field: 'uuid'
[01:29:30.698]   - Field: 'seed'
[01:29:30.698]   - Field: 'version'
[01:29:30.699]   - Field: 'result'
[01:29:30.699]   - Field: 'asynchronous'
[01:29:30.699]   - Field: 'calls'
[01:29:30.699]   - Field: 'globals'
[01:29:30.700]   - Field: 'stdout'
[01:29:30.700]   - Field: 'earlySignal'
[01:29:30.700]   - Field: 'lazy'
[01:29:30.700]   - Field: 'state'
[01:29:30.700] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:30.701] - Launch lazy future ...
[01:29:30.701] Packages needed by the future expression (n = 0): <none>
[01:29:30.701] Packages needed by future strategies (n = 0): <none>
[01:29:30.702] {
[01:29:30.702]     {
[01:29:30.702]         {
[01:29:30.702]             ...future.startTime <- base::Sys.time()
[01:29:30.702]             {
[01:29:30.702]                 {
[01:29:30.702]                   {
[01:29:30.702]                     {
[01:29:30.702]                       base::local({
[01:29:30.702]                         has_future <- base::requireNamespace("future", 
[01:29:30.702]                           quietly = TRUE)
[01:29:30.702]                         if (has_future) {
[01:29:30.702]                           ns <- base::getNamespace("future")
[01:29:30.702]                           version <- ns[[".package"]][["version"]]
[01:29:30.702]                           if (is.null(version)) 
[01:29:30.702]                             version <- utils::packageVersion("future")
[01:29:30.702]                         }
[01:29:30.702]                         else {
[01:29:30.702]                           version <- NULL
[01:29:30.702]                         }
[01:29:30.702]                         if (!has_future || version < "1.8.0") {
[01:29:30.702]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:30.702]                             "", base::R.version$version.string), 
[01:29:30.702]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:30.702]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:30.702]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:30.702]                               "release", "version")], collapse = " "), 
[01:29:30.702]                             hostname = base::Sys.info()[["nodename"]])
[01:29:30.702]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:30.702]                             info)
[01:29:30.702]                           info <- base::paste(info, collapse = "; ")
[01:29:30.702]                           if (!has_future) {
[01:29:30.702]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:30.702]                               info)
[01:29:30.702]                           }
[01:29:30.702]                           else {
[01:29:30.702]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:30.702]                               info, version)
[01:29:30.702]                           }
[01:29:30.702]                           base::stop(msg)
[01:29:30.702]                         }
[01:29:30.702]                       })
[01:29:30.702]                     }
[01:29:30.702]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:30.702]                     base::options(mc.cores = 1L)
[01:29:30.702]                   }
[01:29:30.702]                   options(future.plan = NULL)
[01:29:30.702]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.702]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:30.702]                 }
[01:29:30.702]                 ...future.workdir <- getwd()
[01:29:30.702]             }
[01:29:30.702]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:30.702]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:30.702]         }
[01:29:30.702]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:30.702]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:30.702]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:30.702]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:30.702]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:30.702]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:30.702]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:30.702]             base::names(...future.oldOptions))
[01:29:30.702]     }
[01:29:30.702]     if (FALSE) {
[01:29:30.702]     }
[01:29:30.702]     else {
[01:29:30.702]         if (TRUE) {
[01:29:30.702]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:30.702]                 open = "w")
[01:29:30.702]         }
[01:29:30.702]         else {
[01:29:30.702]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:30.702]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:30.702]         }
[01:29:30.702]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:30.702]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:30.702]             base::sink(type = "output", split = FALSE)
[01:29:30.702]             base::close(...future.stdout)
[01:29:30.702]         }, add = TRUE)
[01:29:30.702]     }
[01:29:30.702]     ...future.frame <- base::sys.nframe()
[01:29:30.702]     ...future.conditions <- base::list()
[01:29:30.702]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:30.702]     if (FALSE) {
[01:29:30.702]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:30.702]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:30.702]     }
[01:29:30.702]     ...future.result <- base::tryCatch({
[01:29:30.702]         base::withCallingHandlers({
[01:29:30.702]             ...future.value <- base::withVisible(base::local({
[01:29:30.702]                 ...future.makeSendCondition <- base::local({
[01:29:30.702]                   sendCondition <- NULL
[01:29:30.702]                   function(frame = 1L) {
[01:29:30.702]                     if (is.function(sendCondition)) 
[01:29:30.702]                       return(sendCondition)
[01:29:30.702]                     ns <- getNamespace("parallel")
[01:29:30.702]                     if (exists("sendData", mode = "function", 
[01:29:30.702]                       envir = ns)) {
[01:29:30.702]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:30.702]                         envir = ns)
[01:29:30.702]                       envir <- sys.frame(frame)
[01:29:30.702]                       master <- NULL
[01:29:30.702]                       while (!identical(envir, .GlobalEnv) && 
[01:29:30.702]                         !identical(envir, emptyenv())) {
[01:29:30.702]                         if (exists("master", mode = "list", envir = envir, 
[01:29:30.702]                           inherits = FALSE)) {
[01:29:30.702]                           master <- get("master", mode = "list", 
[01:29:30.702]                             envir = envir, inherits = FALSE)
[01:29:30.702]                           if (inherits(master, c("SOCKnode", 
[01:29:30.702]                             "SOCK0node"))) {
[01:29:30.702]                             sendCondition <<- function(cond) {
[01:29:30.702]                               data <- list(type = "VALUE", value = cond, 
[01:29:30.702]                                 success = TRUE)
[01:29:30.702]                               parallel_sendData(master, data)
[01:29:30.702]                             }
[01:29:30.702]                             return(sendCondition)
[01:29:30.702]                           }
[01:29:30.702]                         }
[01:29:30.702]                         frame <- frame + 1L
[01:29:30.702]                         envir <- sys.frame(frame)
[01:29:30.702]                       }
[01:29:30.702]                     }
[01:29:30.702]                     sendCondition <<- function(cond) NULL
[01:29:30.702]                   }
[01:29:30.702]                 })
[01:29:30.702]                 withCallingHandlers({
[01:29:30.702]                   {
[01:29:30.702]                     sample(x, size = 1L)
[01:29:30.702]                   }
[01:29:30.702]                 }, immediateCondition = function(cond) {
[01:29:30.702]                   sendCondition <- ...future.makeSendCondition()
[01:29:30.702]                   sendCondition(cond)
[01:29:30.702]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.702]                   {
[01:29:30.702]                     inherits <- base::inherits
[01:29:30.702]                     invokeRestart <- base::invokeRestart
[01:29:30.702]                     is.null <- base::is.null
[01:29:30.702]                     muffled <- FALSE
[01:29:30.702]                     if (inherits(cond, "message")) {
[01:29:30.702]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:30.702]                       if (muffled) 
[01:29:30.702]                         invokeRestart("muffleMessage")
[01:29:30.702]                     }
[01:29:30.702]                     else if (inherits(cond, "warning")) {
[01:29:30.702]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:30.702]                       if (muffled) 
[01:29:30.702]                         invokeRestart("muffleWarning")
[01:29:30.702]                     }
[01:29:30.702]                     else if (inherits(cond, "condition")) {
[01:29:30.702]                       if (!is.null(pattern)) {
[01:29:30.702]                         computeRestarts <- base::computeRestarts
[01:29:30.702]                         grepl <- base::grepl
[01:29:30.702]                         restarts <- computeRestarts(cond)
[01:29:30.702]                         for (restart in restarts) {
[01:29:30.702]                           name <- restart$name
[01:29:30.702]                           if (is.null(name)) 
[01:29:30.702]                             next
[01:29:30.702]                           if (!grepl(pattern, name)) 
[01:29:30.702]                             next
[01:29:30.702]                           invokeRestart(restart)
[01:29:30.702]                           muffled <- TRUE
[01:29:30.702]                           break
[01:29:30.702]                         }
[01:29:30.702]                       }
[01:29:30.702]                     }
[01:29:30.702]                     invisible(muffled)
[01:29:30.702]                   }
[01:29:30.702]                   muffleCondition(cond)
[01:29:30.702]                 })
[01:29:30.702]             }))
[01:29:30.702]             future::FutureResult(value = ...future.value$value, 
[01:29:30.702]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.702]                   ...future.rng), globalenv = if (FALSE) 
[01:29:30.702]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:30.702]                     ...future.globalenv.names))
[01:29:30.702]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:30.702]         }, condition = base::local({
[01:29:30.702]             c <- base::c
[01:29:30.702]             inherits <- base::inherits
[01:29:30.702]             invokeRestart <- base::invokeRestart
[01:29:30.702]             length <- base::length
[01:29:30.702]             list <- base::list
[01:29:30.702]             seq.int <- base::seq.int
[01:29:30.702]             signalCondition <- base::signalCondition
[01:29:30.702]             sys.calls <- base::sys.calls
[01:29:30.702]             `[[` <- base::`[[`
[01:29:30.702]             `+` <- base::`+`
[01:29:30.702]             `<<-` <- base::`<<-`
[01:29:30.702]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:30.702]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:30.702]                   3L)]
[01:29:30.702]             }
[01:29:30.702]             function(cond) {
[01:29:30.702]                 is_error <- inherits(cond, "error")
[01:29:30.702]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:30.702]                   NULL)
[01:29:30.702]                 if (is_error) {
[01:29:30.702]                   sessionInformation <- function() {
[01:29:30.702]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:30.702]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:30.702]                       search = base::search(), system = base::Sys.info())
[01:29:30.702]                   }
[01:29:30.702]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.702]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:30.702]                     cond$call), session = sessionInformation(), 
[01:29:30.702]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:30.702]                   signalCondition(cond)
[01:29:30.702]                 }
[01:29:30.702]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:30.702]                 "immediateCondition"))) {
[01:29:30.702]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:30.702]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.702]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:30.702]                   if (TRUE && !signal) {
[01:29:30.702]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.702]                     {
[01:29:30.702]                       inherits <- base::inherits
[01:29:30.702]                       invokeRestart <- base::invokeRestart
[01:29:30.702]                       is.null <- base::is.null
[01:29:30.702]                       muffled <- FALSE
[01:29:30.702]                       if (inherits(cond, "message")) {
[01:29:30.702]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.702]                         if (muffled) 
[01:29:30.702]                           invokeRestart("muffleMessage")
[01:29:30.702]                       }
[01:29:30.702]                       else if (inherits(cond, "warning")) {
[01:29:30.702]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.702]                         if (muffled) 
[01:29:30.702]                           invokeRestart("muffleWarning")
[01:29:30.702]                       }
[01:29:30.702]                       else if (inherits(cond, "condition")) {
[01:29:30.702]                         if (!is.null(pattern)) {
[01:29:30.702]                           computeRestarts <- base::computeRestarts
[01:29:30.702]                           grepl <- base::grepl
[01:29:30.702]                           restarts <- computeRestarts(cond)
[01:29:30.702]                           for (restart in restarts) {
[01:29:30.702]                             name <- restart$name
[01:29:30.702]                             if (is.null(name)) 
[01:29:30.702]                               next
[01:29:30.702]                             if (!grepl(pattern, name)) 
[01:29:30.702]                               next
[01:29:30.702]                             invokeRestart(restart)
[01:29:30.702]                             muffled <- TRUE
[01:29:30.702]                             break
[01:29:30.702]                           }
[01:29:30.702]                         }
[01:29:30.702]                       }
[01:29:30.702]                       invisible(muffled)
[01:29:30.702]                     }
[01:29:30.702]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.702]                   }
[01:29:30.702]                 }
[01:29:30.702]                 else {
[01:29:30.702]                   if (TRUE) {
[01:29:30.702]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.702]                     {
[01:29:30.702]                       inherits <- base::inherits
[01:29:30.702]                       invokeRestart <- base::invokeRestart
[01:29:30.702]                       is.null <- base::is.null
[01:29:30.702]                       muffled <- FALSE
[01:29:30.702]                       if (inherits(cond, "message")) {
[01:29:30.702]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.702]                         if (muffled) 
[01:29:30.702]                           invokeRestart("muffleMessage")
[01:29:30.702]                       }
[01:29:30.702]                       else if (inherits(cond, "warning")) {
[01:29:30.702]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.702]                         if (muffled) 
[01:29:30.702]                           invokeRestart("muffleWarning")
[01:29:30.702]                       }
[01:29:30.702]                       else if (inherits(cond, "condition")) {
[01:29:30.702]                         if (!is.null(pattern)) {
[01:29:30.702]                           computeRestarts <- base::computeRestarts
[01:29:30.702]                           grepl <- base::grepl
[01:29:30.702]                           restarts <- computeRestarts(cond)
[01:29:30.702]                           for (restart in restarts) {
[01:29:30.702]                             name <- restart$name
[01:29:30.702]                             if (is.null(name)) 
[01:29:30.702]                               next
[01:29:30.702]                             if (!grepl(pattern, name)) 
[01:29:30.702]                               next
[01:29:30.702]                             invokeRestart(restart)
[01:29:30.702]                             muffled <- TRUE
[01:29:30.702]                             break
[01:29:30.702]                           }
[01:29:30.702]                         }
[01:29:30.702]                       }
[01:29:30.702]                       invisible(muffled)
[01:29:30.702]                     }
[01:29:30.702]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.702]                   }
[01:29:30.702]                 }
[01:29:30.702]             }
[01:29:30.702]         }))
[01:29:30.702]     }, error = function(ex) {
[01:29:30.702]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:30.702]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.702]                 ...future.rng), started = ...future.startTime, 
[01:29:30.702]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:30.702]             version = "1.8"), class = "FutureResult")
[01:29:30.702]     }, finally = {
[01:29:30.702]         if (!identical(...future.workdir, getwd())) 
[01:29:30.702]             setwd(...future.workdir)
[01:29:30.702]         {
[01:29:30.702]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:30.702]                 ...future.oldOptions$nwarnings <- NULL
[01:29:30.702]             }
[01:29:30.702]             base::options(...future.oldOptions)
[01:29:30.702]             if (.Platform$OS.type == "windows") {
[01:29:30.702]                 old_names <- names(...future.oldEnvVars)
[01:29:30.702]                 envs <- base::Sys.getenv()
[01:29:30.702]                 names <- names(envs)
[01:29:30.702]                 common <- intersect(names, old_names)
[01:29:30.702]                 added <- setdiff(names, old_names)
[01:29:30.702]                 removed <- setdiff(old_names, names)
[01:29:30.702]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:30.702]                   envs[common]]
[01:29:30.702]                 NAMES <- toupper(changed)
[01:29:30.702]                 args <- list()
[01:29:30.702]                 for (kk in seq_along(NAMES)) {
[01:29:30.702]                   name <- changed[[kk]]
[01:29:30.702]                   NAME <- NAMES[[kk]]
[01:29:30.702]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.702]                     next
[01:29:30.702]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.702]                 }
[01:29:30.702]                 NAMES <- toupper(added)
[01:29:30.702]                 for (kk in seq_along(NAMES)) {
[01:29:30.702]                   name <- added[[kk]]
[01:29:30.702]                   NAME <- NAMES[[kk]]
[01:29:30.702]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.702]                     next
[01:29:30.702]                   args[[name]] <- ""
[01:29:30.702]                 }
[01:29:30.702]                 NAMES <- toupper(removed)
[01:29:30.702]                 for (kk in seq_along(NAMES)) {
[01:29:30.702]                   name <- removed[[kk]]
[01:29:30.702]                   NAME <- NAMES[[kk]]
[01:29:30.702]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.702]                     next
[01:29:30.702]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.702]                 }
[01:29:30.702]                 if (length(args) > 0) 
[01:29:30.702]                   base::do.call(base::Sys.setenv, args = args)
[01:29:30.702]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:30.702]             }
[01:29:30.702]             else {
[01:29:30.702]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:30.702]             }
[01:29:30.702]             {
[01:29:30.702]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:30.702]                   0L) {
[01:29:30.702]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:30.702]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:30.702]                   base::options(opts)
[01:29:30.702]                 }
[01:29:30.702]                 {
[01:29:30.702]                   {
[01:29:30.702]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:30.702]                     NULL
[01:29:30.702]                   }
[01:29:30.702]                   options(future.plan = NULL)
[01:29:30.702]                   if (is.na(NA_character_)) 
[01:29:30.702]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.702]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:30.702]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:30.702]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:30.702]                     envir = parent.frame()) 
[01:29:30.702]                   {
[01:29:30.702]                     if (is.function(workers)) 
[01:29:30.702]                       workers <- workers()
[01:29:30.702]                     workers <- structure(as.integer(workers), 
[01:29:30.702]                       class = class(workers))
[01:29:30.702]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:30.702]                       workers >= 1)
[01:29:30.702]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:30.702]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:30.702]                     }
[01:29:30.702]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:30.702]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:30.702]                       envir = envir)
[01:29:30.702]                     if (!future$lazy) 
[01:29:30.702]                       future <- run(future)
[01:29:30.702]                     invisible(future)
[01:29:30.702]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:30.702]                 }
[01:29:30.702]             }
[01:29:30.702]         }
[01:29:30.702]     })
[01:29:30.702]     if (TRUE) {
[01:29:30.702]         base::sink(type = "output", split = FALSE)
[01:29:30.702]         if (TRUE) {
[01:29:30.702]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:30.702]         }
[01:29:30.702]         else {
[01:29:30.702]             ...future.result["stdout"] <- base::list(NULL)
[01:29:30.702]         }
[01:29:30.702]         base::close(...future.stdout)
[01:29:30.702]         ...future.stdout <- NULL
[01:29:30.702]     }
[01:29:30.702]     ...future.result$conditions <- ...future.conditions
[01:29:30.702]     ...future.result$finished <- base::Sys.time()
[01:29:30.702]     ...future.result
[01:29:30.702] }
[01:29:30.708] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:30.708] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:30.709] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:30.709] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:30.710] MultisessionFuture started
[01:29:30.710] - Launch lazy future ... done
[01:29:30.710] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_2-506356'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96a7615d8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[01:29:30.726] receiveMessageFromWorker() for ClusterFuture ...
[01:29:30.726] - Validating connection of MultisessionFuture
[01:29:30.727] - received message: FutureResult
[01:29:30.727] - Received FutureResult
[01:29:30.727] - Erased future from FutureRegistry
[01:29:30.728] result() for ClusterFuture ...
[01:29:30.728] - result already collected: FutureResult
[01:29:30.728] result() for ClusterFuture ... done
[01:29:30.728] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.729] getGlobalsAndPackages() ...
[01:29:30.729] Searching for globals...
[01:29:30.730] - globals found: [3] '{', 'sample', 'x'
[01:29:30.730] Searching for globals ... DONE
[01:29:30.731] Resolving globals: FALSE
[01:29:30.731] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:30.732] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:30.732] - globals: [1] 'x'
[01:29:30.732] 
[01:29:30.732] getGlobalsAndPackages() ... DONE
[01:29:30.733] run() for 'Future' ...
[01:29:30.733] - state: 'created'
[01:29:30.733] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:30.748] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.748] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:30.748]   - Field: 'node'
[01:29:30.749]   - Field: 'label'
[01:29:30.749]   - Field: 'local'
[01:29:30.749]   - Field: 'owner'
[01:29:30.749]   - Field: 'envir'
[01:29:30.749]   - Field: 'workers'
[01:29:30.749]   - Field: 'packages'
[01:29:30.750]   - Field: 'gc'
[01:29:30.750]   - Field: 'conditions'
[01:29:30.750]   - Field: 'persistent'
[01:29:30.750]   - Field: 'expr'
[01:29:30.750]   - Field: 'uuid'
[01:29:30.751]   - Field: 'seed'
[01:29:30.751]   - Field: 'version'
[01:29:30.751]   - Field: 'result'
[01:29:30.751]   - Field: 'asynchronous'
[01:29:30.751]   - Field: 'calls'
[01:29:30.751]   - Field: 'globals'
[01:29:30.752]   - Field: 'stdout'
[01:29:30.752]   - Field: 'earlySignal'
[01:29:30.752]   - Field: 'lazy'
[01:29:30.752]   - Field: 'state'
[01:29:30.753] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:30.753] - Launch lazy future ...
[01:29:30.753] Packages needed by the future expression (n = 0): <none>
[01:29:30.753] Packages needed by future strategies (n = 0): <none>
[01:29:30.754] {
[01:29:30.754]     {
[01:29:30.754]         {
[01:29:30.754]             ...future.startTime <- base::Sys.time()
[01:29:30.754]             {
[01:29:30.754]                 {
[01:29:30.754]                   {
[01:29:30.754]                     {
[01:29:30.754]                       base::local({
[01:29:30.754]                         has_future <- base::requireNamespace("future", 
[01:29:30.754]                           quietly = TRUE)
[01:29:30.754]                         if (has_future) {
[01:29:30.754]                           ns <- base::getNamespace("future")
[01:29:30.754]                           version <- ns[[".package"]][["version"]]
[01:29:30.754]                           if (is.null(version)) 
[01:29:30.754]                             version <- utils::packageVersion("future")
[01:29:30.754]                         }
[01:29:30.754]                         else {
[01:29:30.754]                           version <- NULL
[01:29:30.754]                         }
[01:29:30.754]                         if (!has_future || version < "1.8.0") {
[01:29:30.754]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:30.754]                             "", base::R.version$version.string), 
[01:29:30.754]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:30.754]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:30.754]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:30.754]                               "release", "version")], collapse = " "), 
[01:29:30.754]                             hostname = base::Sys.info()[["nodename"]])
[01:29:30.754]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:30.754]                             info)
[01:29:30.754]                           info <- base::paste(info, collapse = "; ")
[01:29:30.754]                           if (!has_future) {
[01:29:30.754]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:30.754]                               info)
[01:29:30.754]                           }
[01:29:30.754]                           else {
[01:29:30.754]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:30.754]                               info, version)
[01:29:30.754]                           }
[01:29:30.754]                           base::stop(msg)
[01:29:30.754]                         }
[01:29:30.754]                       })
[01:29:30.754]                     }
[01:29:30.754]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:30.754]                     base::options(mc.cores = 1L)
[01:29:30.754]                   }
[01:29:30.754]                   options(future.plan = NULL)
[01:29:30.754]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.754]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:30.754]                 }
[01:29:30.754]                 ...future.workdir <- getwd()
[01:29:30.754]             }
[01:29:30.754]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:30.754]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:30.754]         }
[01:29:30.754]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:30.754]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:30.754]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:30.754]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:30.754]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:30.754]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:30.754]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:30.754]             base::names(...future.oldOptions))
[01:29:30.754]     }
[01:29:30.754]     if (FALSE) {
[01:29:30.754]     }
[01:29:30.754]     else {
[01:29:30.754]         if (TRUE) {
[01:29:30.754]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:30.754]                 open = "w")
[01:29:30.754]         }
[01:29:30.754]         else {
[01:29:30.754]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:30.754]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:30.754]         }
[01:29:30.754]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:30.754]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:30.754]             base::sink(type = "output", split = FALSE)
[01:29:30.754]             base::close(...future.stdout)
[01:29:30.754]         }, add = TRUE)
[01:29:30.754]     }
[01:29:30.754]     ...future.frame <- base::sys.nframe()
[01:29:30.754]     ...future.conditions <- base::list()
[01:29:30.754]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:30.754]     if (FALSE) {
[01:29:30.754]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:30.754]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:30.754]     }
[01:29:30.754]     ...future.result <- base::tryCatch({
[01:29:30.754]         base::withCallingHandlers({
[01:29:30.754]             ...future.value <- base::withVisible(base::local({
[01:29:30.754]                 ...future.makeSendCondition <- base::local({
[01:29:30.754]                   sendCondition <- NULL
[01:29:30.754]                   function(frame = 1L) {
[01:29:30.754]                     if (is.function(sendCondition)) 
[01:29:30.754]                       return(sendCondition)
[01:29:30.754]                     ns <- getNamespace("parallel")
[01:29:30.754]                     if (exists("sendData", mode = "function", 
[01:29:30.754]                       envir = ns)) {
[01:29:30.754]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:30.754]                         envir = ns)
[01:29:30.754]                       envir <- sys.frame(frame)
[01:29:30.754]                       master <- NULL
[01:29:30.754]                       while (!identical(envir, .GlobalEnv) && 
[01:29:30.754]                         !identical(envir, emptyenv())) {
[01:29:30.754]                         if (exists("master", mode = "list", envir = envir, 
[01:29:30.754]                           inherits = FALSE)) {
[01:29:30.754]                           master <- get("master", mode = "list", 
[01:29:30.754]                             envir = envir, inherits = FALSE)
[01:29:30.754]                           if (inherits(master, c("SOCKnode", 
[01:29:30.754]                             "SOCK0node"))) {
[01:29:30.754]                             sendCondition <<- function(cond) {
[01:29:30.754]                               data <- list(type = "VALUE", value = cond, 
[01:29:30.754]                                 success = TRUE)
[01:29:30.754]                               parallel_sendData(master, data)
[01:29:30.754]                             }
[01:29:30.754]                             return(sendCondition)
[01:29:30.754]                           }
[01:29:30.754]                         }
[01:29:30.754]                         frame <- frame + 1L
[01:29:30.754]                         envir <- sys.frame(frame)
[01:29:30.754]                       }
[01:29:30.754]                     }
[01:29:30.754]                     sendCondition <<- function(cond) NULL
[01:29:30.754]                   }
[01:29:30.754]                 })
[01:29:30.754]                 withCallingHandlers({
[01:29:30.754]                   {
[01:29:30.754]                     sample(x, size = 1L)
[01:29:30.754]                   }
[01:29:30.754]                 }, immediateCondition = function(cond) {
[01:29:30.754]                   sendCondition <- ...future.makeSendCondition()
[01:29:30.754]                   sendCondition(cond)
[01:29:30.754]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.754]                   {
[01:29:30.754]                     inherits <- base::inherits
[01:29:30.754]                     invokeRestart <- base::invokeRestart
[01:29:30.754]                     is.null <- base::is.null
[01:29:30.754]                     muffled <- FALSE
[01:29:30.754]                     if (inherits(cond, "message")) {
[01:29:30.754]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:30.754]                       if (muffled) 
[01:29:30.754]                         invokeRestart("muffleMessage")
[01:29:30.754]                     }
[01:29:30.754]                     else if (inherits(cond, "warning")) {
[01:29:30.754]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:30.754]                       if (muffled) 
[01:29:30.754]                         invokeRestart("muffleWarning")
[01:29:30.754]                     }
[01:29:30.754]                     else if (inherits(cond, "condition")) {
[01:29:30.754]                       if (!is.null(pattern)) {
[01:29:30.754]                         computeRestarts <- base::computeRestarts
[01:29:30.754]                         grepl <- base::grepl
[01:29:30.754]                         restarts <- computeRestarts(cond)
[01:29:30.754]                         for (restart in restarts) {
[01:29:30.754]                           name <- restart$name
[01:29:30.754]                           if (is.null(name)) 
[01:29:30.754]                             next
[01:29:30.754]                           if (!grepl(pattern, name)) 
[01:29:30.754]                             next
[01:29:30.754]                           invokeRestart(restart)
[01:29:30.754]                           muffled <- TRUE
[01:29:30.754]                           break
[01:29:30.754]                         }
[01:29:30.754]                       }
[01:29:30.754]                     }
[01:29:30.754]                     invisible(muffled)
[01:29:30.754]                   }
[01:29:30.754]                   muffleCondition(cond)
[01:29:30.754]                 })
[01:29:30.754]             }))
[01:29:30.754]             future::FutureResult(value = ...future.value$value, 
[01:29:30.754]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.754]                   ...future.rng), globalenv = if (FALSE) 
[01:29:30.754]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:30.754]                     ...future.globalenv.names))
[01:29:30.754]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:30.754]         }, condition = base::local({
[01:29:30.754]             c <- base::c
[01:29:30.754]             inherits <- base::inherits
[01:29:30.754]             invokeRestart <- base::invokeRestart
[01:29:30.754]             length <- base::length
[01:29:30.754]             list <- base::list
[01:29:30.754]             seq.int <- base::seq.int
[01:29:30.754]             signalCondition <- base::signalCondition
[01:29:30.754]             sys.calls <- base::sys.calls
[01:29:30.754]             `[[` <- base::`[[`
[01:29:30.754]             `+` <- base::`+`
[01:29:30.754]             `<<-` <- base::`<<-`
[01:29:30.754]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:30.754]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:30.754]                   3L)]
[01:29:30.754]             }
[01:29:30.754]             function(cond) {
[01:29:30.754]                 is_error <- inherits(cond, "error")
[01:29:30.754]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:30.754]                   NULL)
[01:29:30.754]                 if (is_error) {
[01:29:30.754]                   sessionInformation <- function() {
[01:29:30.754]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:30.754]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:30.754]                       search = base::search(), system = base::Sys.info())
[01:29:30.754]                   }
[01:29:30.754]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.754]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:30.754]                     cond$call), session = sessionInformation(), 
[01:29:30.754]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:30.754]                   signalCondition(cond)
[01:29:30.754]                 }
[01:29:30.754]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:30.754]                 "immediateCondition"))) {
[01:29:30.754]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:30.754]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.754]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:30.754]                   if (TRUE && !signal) {
[01:29:30.754]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.754]                     {
[01:29:30.754]                       inherits <- base::inherits
[01:29:30.754]                       invokeRestart <- base::invokeRestart
[01:29:30.754]                       is.null <- base::is.null
[01:29:30.754]                       muffled <- FALSE
[01:29:30.754]                       if (inherits(cond, "message")) {
[01:29:30.754]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.754]                         if (muffled) 
[01:29:30.754]                           invokeRestart("muffleMessage")
[01:29:30.754]                       }
[01:29:30.754]                       else if (inherits(cond, "warning")) {
[01:29:30.754]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.754]                         if (muffled) 
[01:29:30.754]                           invokeRestart("muffleWarning")
[01:29:30.754]                       }
[01:29:30.754]                       else if (inherits(cond, "condition")) {
[01:29:30.754]                         if (!is.null(pattern)) {
[01:29:30.754]                           computeRestarts <- base::computeRestarts
[01:29:30.754]                           grepl <- base::grepl
[01:29:30.754]                           restarts <- computeRestarts(cond)
[01:29:30.754]                           for (restart in restarts) {
[01:29:30.754]                             name <- restart$name
[01:29:30.754]                             if (is.null(name)) 
[01:29:30.754]                               next
[01:29:30.754]                             if (!grepl(pattern, name)) 
[01:29:30.754]                               next
[01:29:30.754]                             invokeRestart(restart)
[01:29:30.754]                             muffled <- TRUE
[01:29:30.754]                             break
[01:29:30.754]                           }
[01:29:30.754]                         }
[01:29:30.754]                       }
[01:29:30.754]                       invisible(muffled)
[01:29:30.754]                     }
[01:29:30.754]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.754]                   }
[01:29:30.754]                 }
[01:29:30.754]                 else {
[01:29:30.754]                   if (TRUE) {
[01:29:30.754]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.754]                     {
[01:29:30.754]                       inherits <- base::inherits
[01:29:30.754]                       invokeRestart <- base::invokeRestart
[01:29:30.754]                       is.null <- base::is.null
[01:29:30.754]                       muffled <- FALSE
[01:29:30.754]                       if (inherits(cond, "message")) {
[01:29:30.754]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.754]                         if (muffled) 
[01:29:30.754]                           invokeRestart("muffleMessage")
[01:29:30.754]                       }
[01:29:30.754]                       else if (inherits(cond, "warning")) {
[01:29:30.754]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.754]                         if (muffled) 
[01:29:30.754]                           invokeRestart("muffleWarning")
[01:29:30.754]                       }
[01:29:30.754]                       else if (inherits(cond, "condition")) {
[01:29:30.754]                         if (!is.null(pattern)) {
[01:29:30.754]                           computeRestarts <- base::computeRestarts
[01:29:30.754]                           grepl <- base::grepl
[01:29:30.754]                           restarts <- computeRestarts(cond)
[01:29:30.754]                           for (restart in restarts) {
[01:29:30.754]                             name <- restart$name
[01:29:30.754]                             if (is.null(name)) 
[01:29:30.754]                               next
[01:29:30.754]                             if (!grepl(pattern, name)) 
[01:29:30.754]                               next
[01:29:30.754]                             invokeRestart(restart)
[01:29:30.754]                             muffled <- TRUE
[01:29:30.754]                             break
[01:29:30.754]                           }
[01:29:30.754]                         }
[01:29:30.754]                       }
[01:29:30.754]                       invisible(muffled)
[01:29:30.754]                     }
[01:29:30.754]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.754]                   }
[01:29:30.754]                 }
[01:29:30.754]             }
[01:29:30.754]         }))
[01:29:30.754]     }, error = function(ex) {
[01:29:30.754]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:30.754]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.754]                 ...future.rng), started = ...future.startTime, 
[01:29:30.754]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:30.754]             version = "1.8"), class = "FutureResult")
[01:29:30.754]     }, finally = {
[01:29:30.754]         if (!identical(...future.workdir, getwd())) 
[01:29:30.754]             setwd(...future.workdir)
[01:29:30.754]         {
[01:29:30.754]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:30.754]                 ...future.oldOptions$nwarnings <- NULL
[01:29:30.754]             }
[01:29:30.754]             base::options(...future.oldOptions)
[01:29:30.754]             if (.Platform$OS.type == "windows") {
[01:29:30.754]                 old_names <- names(...future.oldEnvVars)
[01:29:30.754]                 envs <- base::Sys.getenv()
[01:29:30.754]                 names <- names(envs)
[01:29:30.754]                 common <- intersect(names, old_names)
[01:29:30.754]                 added <- setdiff(names, old_names)
[01:29:30.754]                 removed <- setdiff(old_names, names)
[01:29:30.754]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:30.754]                   envs[common]]
[01:29:30.754]                 NAMES <- toupper(changed)
[01:29:30.754]                 args <- list()
[01:29:30.754]                 for (kk in seq_along(NAMES)) {
[01:29:30.754]                   name <- changed[[kk]]
[01:29:30.754]                   NAME <- NAMES[[kk]]
[01:29:30.754]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.754]                     next
[01:29:30.754]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.754]                 }
[01:29:30.754]                 NAMES <- toupper(added)
[01:29:30.754]                 for (kk in seq_along(NAMES)) {
[01:29:30.754]                   name <- added[[kk]]
[01:29:30.754]                   NAME <- NAMES[[kk]]
[01:29:30.754]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.754]                     next
[01:29:30.754]                   args[[name]] <- ""
[01:29:30.754]                 }
[01:29:30.754]                 NAMES <- toupper(removed)
[01:29:30.754]                 for (kk in seq_along(NAMES)) {
[01:29:30.754]                   name <- removed[[kk]]
[01:29:30.754]                   NAME <- NAMES[[kk]]
[01:29:30.754]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.754]                     next
[01:29:30.754]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.754]                 }
[01:29:30.754]                 if (length(args) > 0) 
[01:29:30.754]                   base::do.call(base::Sys.setenv, args = args)
[01:29:30.754]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:30.754]             }
[01:29:30.754]             else {
[01:29:30.754]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:30.754]             }
[01:29:30.754]             {
[01:29:30.754]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:30.754]                   0L) {
[01:29:30.754]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:30.754]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:30.754]                   base::options(opts)
[01:29:30.754]                 }
[01:29:30.754]                 {
[01:29:30.754]                   {
[01:29:30.754]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:30.754]                     NULL
[01:29:30.754]                   }
[01:29:30.754]                   options(future.plan = NULL)
[01:29:30.754]                   if (is.na(NA_character_)) 
[01:29:30.754]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.754]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:30.754]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:30.754]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:30.754]                     envir = parent.frame()) 
[01:29:30.754]                   {
[01:29:30.754]                     if (is.function(workers)) 
[01:29:30.754]                       workers <- workers()
[01:29:30.754]                     workers <- structure(as.integer(workers), 
[01:29:30.754]                       class = class(workers))
[01:29:30.754]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:30.754]                       workers >= 1)
[01:29:30.754]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:30.754]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:30.754]                     }
[01:29:30.754]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:30.754]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:30.754]                       envir = envir)
[01:29:30.754]                     if (!future$lazy) 
[01:29:30.754]                       future <- run(future)
[01:29:30.754]                     invisible(future)
[01:29:30.754]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:30.754]                 }
[01:29:30.754]             }
[01:29:30.754]         }
[01:29:30.754]     })
[01:29:30.754]     if (TRUE) {
[01:29:30.754]         base::sink(type = "output", split = FALSE)
[01:29:30.754]         if (TRUE) {
[01:29:30.754]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:30.754]         }
[01:29:30.754]         else {
[01:29:30.754]             ...future.result["stdout"] <- base::list(NULL)
[01:29:30.754]         }
[01:29:30.754]         base::close(...future.stdout)
[01:29:30.754]         ...future.stdout <- NULL
[01:29:30.754]     }
[01:29:30.754]     ...future.result$conditions <- ...future.conditions
[01:29:30.754]     ...future.result$finished <- base::Sys.time()
[01:29:30.754]     ...future.result
[01:29:30.754] }
[01:29:30.759] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:30.759] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:30.760] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:30.760] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:30.761] MultisessionFuture started
[01:29:30.761] - Launch lazy future ... done
[01:29:30.761] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_3-588171'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96a7615d8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[01:29:30.776] receiveMessageFromWorker() for ClusterFuture ...
[01:29:30.776] - Validating connection of MultisessionFuture
[01:29:30.777] - received message: FutureResult
[01:29:30.777] - Received FutureResult
[01:29:30.777] - Erased future from FutureRegistry
[01:29:30.777] result() for ClusterFuture ...
[01:29:30.778] - result already collected: FutureResult
[01:29:30.778] result() for ClusterFuture ... done
[01:29:30.778] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.778] getGlobalsAndPackages() ...
[01:29:30.778] Searching for globals...
[01:29:30.780] - globals found: [3] '{', 'sample', 'x'
[01:29:30.780] Searching for globals ... DONE
[01:29:30.780] Resolving globals: FALSE
[01:29:30.781] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:30.781] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:30.781] - globals: [1] 'x'
[01:29:30.781] 
[01:29:30.782] getGlobalsAndPackages() ... DONE
[01:29:30.782] run() for 'Future' ...
[01:29:30.782] - state: 'created'
[01:29:30.782] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:30.796] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.797] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:30.797]   - Field: 'node'
[01:29:30.797]   - Field: 'label'
[01:29:30.797]   - Field: 'local'
[01:29:30.797]   - Field: 'owner'
[01:29:30.798]   - Field: 'envir'
[01:29:30.798]   - Field: 'workers'
[01:29:30.798]   - Field: 'packages'
[01:29:30.798]   - Field: 'gc'
[01:29:30.798]   - Field: 'conditions'
[01:29:30.798]   - Field: 'persistent'
[01:29:30.799]   - Field: 'expr'
[01:29:30.799]   - Field: 'uuid'
[01:29:30.799]   - Field: 'seed'
[01:29:30.800]   - Field: 'version'
[01:29:30.800]   - Field: 'result'
[01:29:30.800]   - Field: 'asynchronous'
[01:29:30.800]   - Field: 'calls'
[01:29:30.800]   - Field: 'globals'
[01:29:30.801]   - Field: 'stdout'
[01:29:30.801]   - Field: 'earlySignal'
[01:29:30.801]   - Field: 'lazy'
[01:29:30.801]   - Field: 'state'
[01:29:30.802] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:30.802] - Launch lazy future ...
[01:29:30.802] Packages needed by the future expression (n = 0): <none>
[01:29:30.803] Packages needed by future strategies (n = 0): <none>
[01:29:30.804] {
[01:29:30.804]     {
[01:29:30.804]         {
[01:29:30.804]             ...future.startTime <- base::Sys.time()
[01:29:30.804]             {
[01:29:30.804]                 {
[01:29:30.804]                   {
[01:29:30.804]                     {
[01:29:30.804]                       base::local({
[01:29:30.804]                         has_future <- base::requireNamespace("future", 
[01:29:30.804]                           quietly = TRUE)
[01:29:30.804]                         if (has_future) {
[01:29:30.804]                           ns <- base::getNamespace("future")
[01:29:30.804]                           version <- ns[[".package"]][["version"]]
[01:29:30.804]                           if (is.null(version)) 
[01:29:30.804]                             version <- utils::packageVersion("future")
[01:29:30.804]                         }
[01:29:30.804]                         else {
[01:29:30.804]                           version <- NULL
[01:29:30.804]                         }
[01:29:30.804]                         if (!has_future || version < "1.8.0") {
[01:29:30.804]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:30.804]                             "", base::R.version$version.string), 
[01:29:30.804]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:30.804]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:30.804]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:30.804]                               "release", "version")], collapse = " "), 
[01:29:30.804]                             hostname = base::Sys.info()[["nodename"]])
[01:29:30.804]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:30.804]                             info)
[01:29:30.804]                           info <- base::paste(info, collapse = "; ")
[01:29:30.804]                           if (!has_future) {
[01:29:30.804]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:30.804]                               info)
[01:29:30.804]                           }
[01:29:30.804]                           else {
[01:29:30.804]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:30.804]                               info, version)
[01:29:30.804]                           }
[01:29:30.804]                           base::stop(msg)
[01:29:30.804]                         }
[01:29:30.804]                       })
[01:29:30.804]                     }
[01:29:30.804]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:30.804]                     base::options(mc.cores = 1L)
[01:29:30.804]                   }
[01:29:30.804]                   options(future.plan = NULL)
[01:29:30.804]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.804]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:30.804]                 }
[01:29:30.804]                 ...future.workdir <- getwd()
[01:29:30.804]             }
[01:29:30.804]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:30.804]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:30.804]         }
[01:29:30.804]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:30.804]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:30.804]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:30.804]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:30.804]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:30.804]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:30.804]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:30.804]             base::names(...future.oldOptions))
[01:29:30.804]     }
[01:29:30.804]     if (FALSE) {
[01:29:30.804]     }
[01:29:30.804]     else {
[01:29:30.804]         if (TRUE) {
[01:29:30.804]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:30.804]                 open = "w")
[01:29:30.804]         }
[01:29:30.804]         else {
[01:29:30.804]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:30.804]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:30.804]         }
[01:29:30.804]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:30.804]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:30.804]             base::sink(type = "output", split = FALSE)
[01:29:30.804]             base::close(...future.stdout)
[01:29:30.804]         }, add = TRUE)
[01:29:30.804]     }
[01:29:30.804]     ...future.frame <- base::sys.nframe()
[01:29:30.804]     ...future.conditions <- base::list()
[01:29:30.804]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:30.804]     if (FALSE) {
[01:29:30.804]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:30.804]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:30.804]     }
[01:29:30.804]     ...future.result <- base::tryCatch({
[01:29:30.804]         base::withCallingHandlers({
[01:29:30.804]             ...future.value <- base::withVisible(base::local({
[01:29:30.804]                 ...future.makeSendCondition <- base::local({
[01:29:30.804]                   sendCondition <- NULL
[01:29:30.804]                   function(frame = 1L) {
[01:29:30.804]                     if (is.function(sendCondition)) 
[01:29:30.804]                       return(sendCondition)
[01:29:30.804]                     ns <- getNamespace("parallel")
[01:29:30.804]                     if (exists("sendData", mode = "function", 
[01:29:30.804]                       envir = ns)) {
[01:29:30.804]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:30.804]                         envir = ns)
[01:29:30.804]                       envir <- sys.frame(frame)
[01:29:30.804]                       master <- NULL
[01:29:30.804]                       while (!identical(envir, .GlobalEnv) && 
[01:29:30.804]                         !identical(envir, emptyenv())) {
[01:29:30.804]                         if (exists("master", mode = "list", envir = envir, 
[01:29:30.804]                           inherits = FALSE)) {
[01:29:30.804]                           master <- get("master", mode = "list", 
[01:29:30.804]                             envir = envir, inherits = FALSE)
[01:29:30.804]                           if (inherits(master, c("SOCKnode", 
[01:29:30.804]                             "SOCK0node"))) {
[01:29:30.804]                             sendCondition <<- function(cond) {
[01:29:30.804]                               data <- list(type = "VALUE", value = cond, 
[01:29:30.804]                                 success = TRUE)
[01:29:30.804]                               parallel_sendData(master, data)
[01:29:30.804]                             }
[01:29:30.804]                             return(sendCondition)
[01:29:30.804]                           }
[01:29:30.804]                         }
[01:29:30.804]                         frame <- frame + 1L
[01:29:30.804]                         envir <- sys.frame(frame)
[01:29:30.804]                       }
[01:29:30.804]                     }
[01:29:30.804]                     sendCondition <<- function(cond) NULL
[01:29:30.804]                   }
[01:29:30.804]                 })
[01:29:30.804]                 withCallingHandlers({
[01:29:30.804]                   {
[01:29:30.804]                     sample(x, size = 1L)
[01:29:30.804]                   }
[01:29:30.804]                 }, immediateCondition = function(cond) {
[01:29:30.804]                   sendCondition <- ...future.makeSendCondition()
[01:29:30.804]                   sendCondition(cond)
[01:29:30.804]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.804]                   {
[01:29:30.804]                     inherits <- base::inherits
[01:29:30.804]                     invokeRestart <- base::invokeRestart
[01:29:30.804]                     is.null <- base::is.null
[01:29:30.804]                     muffled <- FALSE
[01:29:30.804]                     if (inherits(cond, "message")) {
[01:29:30.804]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:30.804]                       if (muffled) 
[01:29:30.804]                         invokeRestart("muffleMessage")
[01:29:30.804]                     }
[01:29:30.804]                     else if (inherits(cond, "warning")) {
[01:29:30.804]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:30.804]                       if (muffled) 
[01:29:30.804]                         invokeRestart("muffleWarning")
[01:29:30.804]                     }
[01:29:30.804]                     else if (inherits(cond, "condition")) {
[01:29:30.804]                       if (!is.null(pattern)) {
[01:29:30.804]                         computeRestarts <- base::computeRestarts
[01:29:30.804]                         grepl <- base::grepl
[01:29:30.804]                         restarts <- computeRestarts(cond)
[01:29:30.804]                         for (restart in restarts) {
[01:29:30.804]                           name <- restart$name
[01:29:30.804]                           if (is.null(name)) 
[01:29:30.804]                             next
[01:29:30.804]                           if (!grepl(pattern, name)) 
[01:29:30.804]                             next
[01:29:30.804]                           invokeRestart(restart)
[01:29:30.804]                           muffled <- TRUE
[01:29:30.804]                           break
[01:29:30.804]                         }
[01:29:30.804]                       }
[01:29:30.804]                     }
[01:29:30.804]                     invisible(muffled)
[01:29:30.804]                   }
[01:29:30.804]                   muffleCondition(cond)
[01:29:30.804]                 })
[01:29:30.804]             }))
[01:29:30.804]             future::FutureResult(value = ...future.value$value, 
[01:29:30.804]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.804]                   ...future.rng), globalenv = if (FALSE) 
[01:29:30.804]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:30.804]                     ...future.globalenv.names))
[01:29:30.804]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:30.804]         }, condition = base::local({
[01:29:30.804]             c <- base::c
[01:29:30.804]             inherits <- base::inherits
[01:29:30.804]             invokeRestart <- base::invokeRestart
[01:29:30.804]             length <- base::length
[01:29:30.804]             list <- base::list
[01:29:30.804]             seq.int <- base::seq.int
[01:29:30.804]             signalCondition <- base::signalCondition
[01:29:30.804]             sys.calls <- base::sys.calls
[01:29:30.804]             `[[` <- base::`[[`
[01:29:30.804]             `+` <- base::`+`
[01:29:30.804]             `<<-` <- base::`<<-`
[01:29:30.804]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:30.804]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:30.804]                   3L)]
[01:29:30.804]             }
[01:29:30.804]             function(cond) {
[01:29:30.804]                 is_error <- inherits(cond, "error")
[01:29:30.804]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:30.804]                   NULL)
[01:29:30.804]                 if (is_error) {
[01:29:30.804]                   sessionInformation <- function() {
[01:29:30.804]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:30.804]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:30.804]                       search = base::search(), system = base::Sys.info())
[01:29:30.804]                   }
[01:29:30.804]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.804]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:30.804]                     cond$call), session = sessionInformation(), 
[01:29:30.804]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:30.804]                   signalCondition(cond)
[01:29:30.804]                 }
[01:29:30.804]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:30.804]                 "immediateCondition"))) {
[01:29:30.804]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:30.804]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.804]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:30.804]                   if (TRUE && !signal) {
[01:29:30.804]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.804]                     {
[01:29:30.804]                       inherits <- base::inherits
[01:29:30.804]                       invokeRestart <- base::invokeRestart
[01:29:30.804]                       is.null <- base::is.null
[01:29:30.804]                       muffled <- FALSE
[01:29:30.804]                       if (inherits(cond, "message")) {
[01:29:30.804]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.804]                         if (muffled) 
[01:29:30.804]                           invokeRestart("muffleMessage")
[01:29:30.804]                       }
[01:29:30.804]                       else if (inherits(cond, "warning")) {
[01:29:30.804]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.804]                         if (muffled) 
[01:29:30.804]                           invokeRestart("muffleWarning")
[01:29:30.804]                       }
[01:29:30.804]                       else if (inherits(cond, "condition")) {
[01:29:30.804]                         if (!is.null(pattern)) {
[01:29:30.804]                           computeRestarts <- base::computeRestarts
[01:29:30.804]                           grepl <- base::grepl
[01:29:30.804]                           restarts <- computeRestarts(cond)
[01:29:30.804]                           for (restart in restarts) {
[01:29:30.804]                             name <- restart$name
[01:29:30.804]                             if (is.null(name)) 
[01:29:30.804]                               next
[01:29:30.804]                             if (!grepl(pattern, name)) 
[01:29:30.804]                               next
[01:29:30.804]                             invokeRestart(restart)
[01:29:30.804]                             muffled <- TRUE
[01:29:30.804]                             break
[01:29:30.804]                           }
[01:29:30.804]                         }
[01:29:30.804]                       }
[01:29:30.804]                       invisible(muffled)
[01:29:30.804]                     }
[01:29:30.804]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.804]                   }
[01:29:30.804]                 }
[01:29:30.804]                 else {
[01:29:30.804]                   if (TRUE) {
[01:29:30.804]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.804]                     {
[01:29:30.804]                       inherits <- base::inherits
[01:29:30.804]                       invokeRestart <- base::invokeRestart
[01:29:30.804]                       is.null <- base::is.null
[01:29:30.804]                       muffled <- FALSE
[01:29:30.804]                       if (inherits(cond, "message")) {
[01:29:30.804]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.804]                         if (muffled) 
[01:29:30.804]                           invokeRestart("muffleMessage")
[01:29:30.804]                       }
[01:29:30.804]                       else if (inherits(cond, "warning")) {
[01:29:30.804]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.804]                         if (muffled) 
[01:29:30.804]                           invokeRestart("muffleWarning")
[01:29:30.804]                       }
[01:29:30.804]                       else if (inherits(cond, "condition")) {
[01:29:30.804]                         if (!is.null(pattern)) {
[01:29:30.804]                           computeRestarts <- base::computeRestarts
[01:29:30.804]                           grepl <- base::grepl
[01:29:30.804]                           restarts <- computeRestarts(cond)
[01:29:30.804]                           for (restart in restarts) {
[01:29:30.804]                             name <- restart$name
[01:29:30.804]                             if (is.null(name)) 
[01:29:30.804]                               next
[01:29:30.804]                             if (!grepl(pattern, name)) 
[01:29:30.804]                               next
[01:29:30.804]                             invokeRestart(restart)
[01:29:30.804]                             muffled <- TRUE
[01:29:30.804]                             break
[01:29:30.804]                           }
[01:29:30.804]                         }
[01:29:30.804]                       }
[01:29:30.804]                       invisible(muffled)
[01:29:30.804]                     }
[01:29:30.804]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.804]                   }
[01:29:30.804]                 }
[01:29:30.804]             }
[01:29:30.804]         }))
[01:29:30.804]     }, error = function(ex) {
[01:29:30.804]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:30.804]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.804]                 ...future.rng), started = ...future.startTime, 
[01:29:30.804]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:30.804]             version = "1.8"), class = "FutureResult")
[01:29:30.804]     }, finally = {
[01:29:30.804]         if (!identical(...future.workdir, getwd())) 
[01:29:30.804]             setwd(...future.workdir)
[01:29:30.804]         {
[01:29:30.804]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:30.804]                 ...future.oldOptions$nwarnings <- NULL
[01:29:30.804]             }
[01:29:30.804]             base::options(...future.oldOptions)
[01:29:30.804]             if (.Platform$OS.type == "windows") {
[01:29:30.804]                 old_names <- names(...future.oldEnvVars)
[01:29:30.804]                 envs <- base::Sys.getenv()
[01:29:30.804]                 names <- names(envs)
[01:29:30.804]                 common <- intersect(names, old_names)
[01:29:30.804]                 added <- setdiff(names, old_names)
[01:29:30.804]                 removed <- setdiff(old_names, names)
[01:29:30.804]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:30.804]                   envs[common]]
[01:29:30.804]                 NAMES <- toupper(changed)
[01:29:30.804]                 args <- list()
[01:29:30.804]                 for (kk in seq_along(NAMES)) {
[01:29:30.804]                   name <- changed[[kk]]
[01:29:30.804]                   NAME <- NAMES[[kk]]
[01:29:30.804]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.804]                     next
[01:29:30.804]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.804]                 }
[01:29:30.804]                 NAMES <- toupper(added)
[01:29:30.804]                 for (kk in seq_along(NAMES)) {
[01:29:30.804]                   name <- added[[kk]]
[01:29:30.804]                   NAME <- NAMES[[kk]]
[01:29:30.804]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.804]                     next
[01:29:30.804]                   args[[name]] <- ""
[01:29:30.804]                 }
[01:29:30.804]                 NAMES <- toupper(removed)
[01:29:30.804]                 for (kk in seq_along(NAMES)) {
[01:29:30.804]                   name <- removed[[kk]]
[01:29:30.804]                   NAME <- NAMES[[kk]]
[01:29:30.804]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.804]                     next
[01:29:30.804]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.804]                 }
[01:29:30.804]                 if (length(args) > 0) 
[01:29:30.804]                   base::do.call(base::Sys.setenv, args = args)
[01:29:30.804]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:30.804]             }
[01:29:30.804]             else {
[01:29:30.804]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:30.804]             }
[01:29:30.804]             {
[01:29:30.804]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:30.804]                   0L) {
[01:29:30.804]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:30.804]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:30.804]                   base::options(opts)
[01:29:30.804]                 }
[01:29:30.804]                 {
[01:29:30.804]                   {
[01:29:30.804]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:30.804]                     NULL
[01:29:30.804]                   }
[01:29:30.804]                   options(future.plan = NULL)
[01:29:30.804]                   if (is.na(NA_character_)) 
[01:29:30.804]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.804]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:30.804]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:30.804]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:30.804]                     envir = parent.frame()) 
[01:29:30.804]                   {
[01:29:30.804]                     if (is.function(workers)) 
[01:29:30.804]                       workers <- workers()
[01:29:30.804]                     workers <- structure(as.integer(workers), 
[01:29:30.804]                       class = class(workers))
[01:29:30.804]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:30.804]                       workers >= 1)
[01:29:30.804]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:30.804]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:30.804]                     }
[01:29:30.804]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:30.804]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:30.804]                       envir = envir)
[01:29:30.804]                     if (!future$lazy) 
[01:29:30.804]                       future <- run(future)
[01:29:30.804]                     invisible(future)
[01:29:30.804]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:30.804]                 }
[01:29:30.804]             }
[01:29:30.804]         }
[01:29:30.804]     })
[01:29:30.804]     if (TRUE) {
[01:29:30.804]         base::sink(type = "output", split = FALSE)
[01:29:30.804]         if (TRUE) {
[01:29:30.804]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:30.804]         }
[01:29:30.804]         else {
[01:29:30.804]             ...future.result["stdout"] <- base::list(NULL)
[01:29:30.804]         }
[01:29:30.804]         base::close(...future.stdout)
[01:29:30.804]         ...future.stdout <- NULL
[01:29:30.804]     }
[01:29:30.804]     ...future.result$conditions <- ...future.conditions
[01:29:30.804]     ...future.result$finished <- base::Sys.time()
[01:29:30.804]     ...future.result
[01:29:30.804] }
[01:29:30.810] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:30.810] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:30.811] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:30.811] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:30.812] MultisessionFuture started
[01:29:30.812] - Launch lazy future ... done
[01:29:30.813] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_4-707243'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96a7615d8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[01:29:30.839] receiveMessageFromWorker() for ClusterFuture ...
[01:29:30.839] - Validating connection of MultisessionFuture
[01:29:30.839] - received message: FutureResult
[01:29:30.840] - Received FutureResult
[01:29:30.840] - Erased future from FutureRegistry
[01:29:30.840] result() for ClusterFuture ...
[01:29:30.840] - result already collected: FutureResult
[01:29:30.840] result() for ClusterFuture ... done
[01:29:30.840] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.841] resolve() on list ...
[01:29:30.841]  recursive: 0
[01:29:30.841]  length: 4
[01:29:30.841] 
[01:29:30.841] Future #1
[01:29:30.842] result() for ClusterFuture ...
[01:29:30.842] - result already collected: FutureResult
[01:29:30.842] result() for ClusterFuture ... done
[01:29:30.842] result() for ClusterFuture ...
[01:29:30.842] - result already collected: FutureResult
[01:29:30.842] result() for ClusterFuture ... done
[01:29:30.843] signalConditionsASAP(MultisessionFuture, pos=1) ...
[01:29:30.843] - nx: 4
[01:29:30.843] - relay: TRUE
[01:29:30.843] - stdout: TRUE
[01:29:30.843] - signal: TRUE
[01:29:30.844] - resignal: FALSE
[01:29:30.844] - force: TRUE
[01:29:30.844] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:30.844] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:30.844]  - until=1
[01:29:30.844]  - relaying element #1
[01:29:30.845] result() for ClusterFuture ...
[01:29:30.845] - result already collected: FutureResult
[01:29:30.845] result() for ClusterFuture ... done
[01:29:30.845] result() for ClusterFuture ...
[01:29:30.845] - result already collected: FutureResult
[01:29:30.845] result() for ClusterFuture ... done
[01:29:30.845] signalConditions() ...
[01:29:30.846]  - include = 'immediateCondition'
[01:29:30.846]  - exclude = 
[01:29:30.846]  - resignal = FALSE
[01:29:30.846]  - Number of conditions: 1
[01:29:30.846] signalConditions() ... done
[01:29:30.847] result() for ClusterFuture ...
[01:29:30.847] - result already collected: FutureResult
[01:29:30.847] result() for ClusterFuture ... done
[01:29:30.847] signalConditions() ...
[01:29:30.847]  - include = 'immediateCondition'
[01:29:30.847]  - exclude = 
[01:29:30.848]  - resignal = FALSE
[01:29:30.848]  - Number of conditions: 1
[01:29:30.848] signalConditions() ... done
[01:29:30.848] result() for ClusterFuture ...
[01:29:30.848] - result already collected: FutureResult
[01:29:30.848] result() for ClusterFuture ... done
[01:29:30.849] signalConditions() ...
[01:29:30.849]  - include = 'condition'
[01:29:30.849]  - exclude = 'immediateCondition'
[01:29:30.849]  - resignal = TRUE
[01:29:30.849]  - Number of conditions: 1
[01:29:30.849]  - Condition #1: 'RngFutureWarning', 'FutureWarning', 'warning', 'RngFutureCondition', 'FutureCondition', 'condition'
[01:29:30.850] signalConditions() ... done
[01:29:30.850] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:30.853] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:30.854] signalConditionsASAP(MultisessionFuture, pos=1) ... done
<RngFutureWarning: UNRELIABLE VALUE: Future ('fsample_1-682326') unexpectedly generated random numbers without specifying argument 'seed'. There is a risk that those random numbers are not statistically sound and the overall results might be invalid. To fix this, specify 'seed=TRUE'. This ensures that proper, parallel-safe random numbers are produced via the L'Ecuyer-CMRG method. To disable this check, use 'seed=NULL', or set option 'future.rng.onMisuse' to "ignore".>


Future UUID: 562c2bf4-38b6-c92d-d92f-79f5dd955ff6


DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
MultisessionFuture:
Label: 'fsample_1-682326'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96a7615d8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Conditions captured: [n=1] 'RngFutureWarning'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'

DEBUG: END TROUBLESHOOTING HELP
[01:29:30.855] getGlobalsAndPackages() ...
[01:29:30.855] Searching for globals...
[01:29:30.856] - globals found: [3] '{', 'sample', 'x'
[01:29:30.857] Searching for globals ... DONE
[01:29:30.857] Resolving globals: FALSE
[01:29:30.857] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:30.858] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:30.858] - globals: [1] 'x'
[01:29:30.858] 
[01:29:30.858] getGlobalsAndPackages() ... DONE
[01:29:30.859] run() for 'Future' ...
[01:29:30.859] - state: 'created'
[01:29:30.859] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:30.873] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.874] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:30.874]   - Field: 'node'
[01:29:30.874]   - Field: 'label'
[01:29:30.874]   - Field: 'local'
[01:29:30.874]   - Field: 'owner'
[01:29:30.875]   - Field: 'envir'
[01:29:30.875]   - Field: 'workers'
[01:29:30.875]   - Field: 'packages'
[01:29:30.875]   - Field: 'gc'
[01:29:30.875]   - Field: 'conditions'
[01:29:30.875]   - Field: 'persistent'
[01:29:30.876]   - Field: 'expr'
[01:29:30.876]   - Field: 'uuid'
[01:29:30.876]   - Field: 'seed'
[01:29:30.876]   - Field: 'version'
[01:29:30.876]   - Field: 'result'
[01:29:30.877]   - Field: 'asynchronous'
[01:29:30.877]   - Field: 'calls'
[01:29:30.877]   - Field: 'globals'
[01:29:30.877]   - Field: 'stdout'
[01:29:30.878]   - Field: 'earlySignal'
[01:29:30.878]   - Field: 'lazy'
[01:29:30.878]   - Field: 'state'
[01:29:30.878] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:30.879] - Launch lazy future ...
[01:29:30.879] Packages needed by the future expression (n = 0): <none>
[01:29:30.880] Packages needed by future strategies (n = 0): <none>
[01:29:30.881] {
[01:29:30.881]     {
[01:29:30.881]         {
[01:29:30.881]             ...future.startTime <- base::Sys.time()
[01:29:30.881]             {
[01:29:30.881]                 {
[01:29:30.881]                   {
[01:29:30.881]                     {
[01:29:30.881]                       base::local({
[01:29:30.881]                         has_future <- base::requireNamespace("future", 
[01:29:30.881]                           quietly = TRUE)
[01:29:30.881]                         if (has_future) {
[01:29:30.881]                           ns <- base::getNamespace("future")
[01:29:30.881]                           version <- ns[[".package"]][["version"]]
[01:29:30.881]                           if (is.null(version)) 
[01:29:30.881]                             version <- utils::packageVersion("future")
[01:29:30.881]                         }
[01:29:30.881]                         else {
[01:29:30.881]                           version <- NULL
[01:29:30.881]                         }
[01:29:30.881]                         if (!has_future || version < "1.8.0") {
[01:29:30.881]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:30.881]                             "", base::R.version$version.string), 
[01:29:30.881]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:30.881]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:30.881]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:30.881]                               "release", "version")], collapse = " "), 
[01:29:30.881]                             hostname = base::Sys.info()[["nodename"]])
[01:29:30.881]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:30.881]                             info)
[01:29:30.881]                           info <- base::paste(info, collapse = "; ")
[01:29:30.881]                           if (!has_future) {
[01:29:30.881]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:30.881]                               info)
[01:29:30.881]                           }
[01:29:30.881]                           else {
[01:29:30.881]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:30.881]                               info, version)
[01:29:30.881]                           }
[01:29:30.881]                           base::stop(msg)
[01:29:30.881]                         }
[01:29:30.881]                       })
[01:29:30.881]                     }
[01:29:30.881]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:30.881]                     base::options(mc.cores = 1L)
[01:29:30.881]                   }
[01:29:30.881]                   options(future.plan = NULL)
[01:29:30.881]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.881]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:30.881]                 }
[01:29:30.881]                 ...future.workdir <- getwd()
[01:29:30.881]             }
[01:29:30.881]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:30.881]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:30.881]         }
[01:29:30.881]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:30.881]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:30.881]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:30.881]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:30.881]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:30.881]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:30.881]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:30.881]             base::names(...future.oldOptions))
[01:29:30.881]     }
[01:29:30.881]     if (FALSE) {
[01:29:30.881]     }
[01:29:30.881]     else {
[01:29:30.881]         if (TRUE) {
[01:29:30.881]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:30.881]                 open = "w")
[01:29:30.881]         }
[01:29:30.881]         else {
[01:29:30.881]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:30.881]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:30.881]         }
[01:29:30.881]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:30.881]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:30.881]             base::sink(type = "output", split = FALSE)
[01:29:30.881]             base::close(...future.stdout)
[01:29:30.881]         }, add = TRUE)
[01:29:30.881]     }
[01:29:30.881]     ...future.frame <- base::sys.nframe()
[01:29:30.881]     ...future.conditions <- base::list()
[01:29:30.881]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:30.881]     if (FALSE) {
[01:29:30.881]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:30.881]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:30.881]     }
[01:29:30.881]     ...future.result <- base::tryCatch({
[01:29:30.881]         base::withCallingHandlers({
[01:29:30.881]             ...future.value <- base::withVisible(base::local({
[01:29:30.881]                 ...future.makeSendCondition <- base::local({
[01:29:30.881]                   sendCondition <- NULL
[01:29:30.881]                   function(frame = 1L) {
[01:29:30.881]                     if (is.function(sendCondition)) 
[01:29:30.881]                       return(sendCondition)
[01:29:30.881]                     ns <- getNamespace("parallel")
[01:29:30.881]                     if (exists("sendData", mode = "function", 
[01:29:30.881]                       envir = ns)) {
[01:29:30.881]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:30.881]                         envir = ns)
[01:29:30.881]                       envir <- sys.frame(frame)
[01:29:30.881]                       master <- NULL
[01:29:30.881]                       while (!identical(envir, .GlobalEnv) && 
[01:29:30.881]                         !identical(envir, emptyenv())) {
[01:29:30.881]                         if (exists("master", mode = "list", envir = envir, 
[01:29:30.881]                           inherits = FALSE)) {
[01:29:30.881]                           master <- get("master", mode = "list", 
[01:29:30.881]                             envir = envir, inherits = FALSE)
[01:29:30.881]                           if (inherits(master, c("SOCKnode", 
[01:29:30.881]                             "SOCK0node"))) {
[01:29:30.881]                             sendCondition <<- function(cond) {
[01:29:30.881]                               data <- list(type = "VALUE", value = cond, 
[01:29:30.881]                                 success = TRUE)
[01:29:30.881]                               parallel_sendData(master, data)
[01:29:30.881]                             }
[01:29:30.881]                             return(sendCondition)
[01:29:30.881]                           }
[01:29:30.881]                         }
[01:29:30.881]                         frame <- frame + 1L
[01:29:30.881]                         envir <- sys.frame(frame)
[01:29:30.881]                       }
[01:29:30.881]                     }
[01:29:30.881]                     sendCondition <<- function(cond) NULL
[01:29:30.881]                   }
[01:29:30.881]                 })
[01:29:30.881]                 withCallingHandlers({
[01:29:30.881]                   {
[01:29:30.881]                     sample(x, size = 1L)
[01:29:30.881]                   }
[01:29:30.881]                 }, immediateCondition = function(cond) {
[01:29:30.881]                   sendCondition <- ...future.makeSendCondition()
[01:29:30.881]                   sendCondition(cond)
[01:29:30.881]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.881]                   {
[01:29:30.881]                     inherits <- base::inherits
[01:29:30.881]                     invokeRestart <- base::invokeRestart
[01:29:30.881]                     is.null <- base::is.null
[01:29:30.881]                     muffled <- FALSE
[01:29:30.881]                     if (inherits(cond, "message")) {
[01:29:30.881]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:30.881]                       if (muffled) 
[01:29:30.881]                         invokeRestart("muffleMessage")
[01:29:30.881]                     }
[01:29:30.881]                     else if (inherits(cond, "warning")) {
[01:29:30.881]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:30.881]                       if (muffled) 
[01:29:30.881]                         invokeRestart("muffleWarning")
[01:29:30.881]                     }
[01:29:30.881]                     else if (inherits(cond, "condition")) {
[01:29:30.881]                       if (!is.null(pattern)) {
[01:29:30.881]                         computeRestarts <- base::computeRestarts
[01:29:30.881]                         grepl <- base::grepl
[01:29:30.881]                         restarts <- computeRestarts(cond)
[01:29:30.881]                         for (restart in restarts) {
[01:29:30.881]                           name <- restart$name
[01:29:30.881]                           if (is.null(name)) 
[01:29:30.881]                             next
[01:29:30.881]                           if (!grepl(pattern, name)) 
[01:29:30.881]                             next
[01:29:30.881]                           invokeRestart(restart)
[01:29:30.881]                           muffled <- TRUE
[01:29:30.881]                           break
[01:29:30.881]                         }
[01:29:30.881]                       }
[01:29:30.881]                     }
[01:29:30.881]                     invisible(muffled)
[01:29:30.881]                   }
[01:29:30.881]                   muffleCondition(cond)
[01:29:30.881]                 })
[01:29:30.881]             }))
[01:29:30.881]             future::FutureResult(value = ...future.value$value, 
[01:29:30.881]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.881]                   ...future.rng), globalenv = if (FALSE) 
[01:29:30.881]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:30.881]                     ...future.globalenv.names))
[01:29:30.881]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:30.881]         }, condition = base::local({
[01:29:30.881]             c <- base::c
[01:29:30.881]             inherits <- base::inherits
[01:29:30.881]             invokeRestart <- base::invokeRestart
[01:29:30.881]             length <- base::length
[01:29:30.881]             list <- base::list
[01:29:30.881]             seq.int <- base::seq.int
[01:29:30.881]             signalCondition <- base::signalCondition
[01:29:30.881]             sys.calls <- base::sys.calls
[01:29:30.881]             `[[` <- base::`[[`
[01:29:30.881]             `+` <- base::`+`
[01:29:30.881]             `<<-` <- base::`<<-`
[01:29:30.881]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:30.881]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:30.881]                   3L)]
[01:29:30.881]             }
[01:29:30.881]             function(cond) {
[01:29:30.881]                 is_error <- inherits(cond, "error")
[01:29:30.881]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:30.881]                   NULL)
[01:29:30.881]                 if (is_error) {
[01:29:30.881]                   sessionInformation <- function() {
[01:29:30.881]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:30.881]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:30.881]                       search = base::search(), system = base::Sys.info())
[01:29:30.881]                   }
[01:29:30.881]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.881]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:30.881]                     cond$call), session = sessionInformation(), 
[01:29:30.881]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:30.881]                   signalCondition(cond)
[01:29:30.881]                 }
[01:29:30.881]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:30.881]                 "immediateCondition"))) {
[01:29:30.881]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:30.881]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.881]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:30.881]                   if (TRUE && !signal) {
[01:29:30.881]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.881]                     {
[01:29:30.881]                       inherits <- base::inherits
[01:29:30.881]                       invokeRestart <- base::invokeRestart
[01:29:30.881]                       is.null <- base::is.null
[01:29:30.881]                       muffled <- FALSE
[01:29:30.881]                       if (inherits(cond, "message")) {
[01:29:30.881]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.881]                         if (muffled) 
[01:29:30.881]                           invokeRestart("muffleMessage")
[01:29:30.881]                       }
[01:29:30.881]                       else if (inherits(cond, "warning")) {
[01:29:30.881]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.881]                         if (muffled) 
[01:29:30.881]                           invokeRestart("muffleWarning")
[01:29:30.881]                       }
[01:29:30.881]                       else if (inherits(cond, "condition")) {
[01:29:30.881]                         if (!is.null(pattern)) {
[01:29:30.881]                           computeRestarts <- base::computeRestarts
[01:29:30.881]                           grepl <- base::grepl
[01:29:30.881]                           restarts <- computeRestarts(cond)
[01:29:30.881]                           for (restart in restarts) {
[01:29:30.881]                             name <- restart$name
[01:29:30.881]                             if (is.null(name)) 
[01:29:30.881]                               next
[01:29:30.881]                             if (!grepl(pattern, name)) 
[01:29:30.881]                               next
[01:29:30.881]                             invokeRestart(restart)
[01:29:30.881]                             muffled <- TRUE
[01:29:30.881]                             break
[01:29:30.881]                           }
[01:29:30.881]                         }
[01:29:30.881]                       }
[01:29:30.881]                       invisible(muffled)
[01:29:30.881]                     }
[01:29:30.881]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.881]                   }
[01:29:30.881]                 }
[01:29:30.881]                 else {
[01:29:30.881]                   if (TRUE) {
[01:29:30.881]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.881]                     {
[01:29:30.881]                       inherits <- base::inherits
[01:29:30.881]                       invokeRestart <- base::invokeRestart
[01:29:30.881]                       is.null <- base::is.null
[01:29:30.881]                       muffled <- FALSE
[01:29:30.881]                       if (inherits(cond, "message")) {
[01:29:30.881]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.881]                         if (muffled) 
[01:29:30.881]                           invokeRestart("muffleMessage")
[01:29:30.881]                       }
[01:29:30.881]                       else if (inherits(cond, "warning")) {
[01:29:30.881]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.881]                         if (muffled) 
[01:29:30.881]                           invokeRestart("muffleWarning")
[01:29:30.881]                       }
[01:29:30.881]                       else if (inherits(cond, "condition")) {
[01:29:30.881]                         if (!is.null(pattern)) {
[01:29:30.881]                           computeRestarts <- base::computeRestarts
[01:29:30.881]                           grepl <- base::grepl
[01:29:30.881]                           restarts <- computeRestarts(cond)
[01:29:30.881]                           for (restart in restarts) {
[01:29:30.881]                             name <- restart$name
[01:29:30.881]                             if (is.null(name)) 
[01:29:30.881]                               next
[01:29:30.881]                             if (!grepl(pattern, name)) 
[01:29:30.881]                               next
[01:29:30.881]                             invokeRestart(restart)
[01:29:30.881]                             muffled <- TRUE
[01:29:30.881]                             break
[01:29:30.881]                           }
[01:29:30.881]                         }
[01:29:30.881]                       }
[01:29:30.881]                       invisible(muffled)
[01:29:30.881]                     }
[01:29:30.881]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.881]                   }
[01:29:30.881]                 }
[01:29:30.881]             }
[01:29:30.881]         }))
[01:29:30.881]     }, error = function(ex) {
[01:29:30.881]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:30.881]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.881]                 ...future.rng), started = ...future.startTime, 
[01:29:30.881]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:30.881]             version = "1.8"), class = "FutureResult")
[01:29:30.881]     }, finally = {
[01:29:30.881]         if (!identical(...future.workdir, getwd())) 
[01:29:30.881]             setwd(...future.workdir)
[01:29:30.881]         {
[01:29:30.881]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:30.881]                 ...future.oldOptions$nwarnings <- NULL
[01:29:30.881]             }
[01:29:30.881]             base::options(...future.oldOptions)
[01:29:30.881]             if (.Platform$OS.type == "windows") {
[01:29:30.881]                 old_names <- names(...future.oldEnvVars)
[01:29:30.881]                 envs <- base::Sys.getenv()
[01:29:30.881]                 names <- names(envs)
[01:29:30.881]                 common <- intersect(names, old_names)
[01:29:30.881]                 added <- setdiff(names, old_names)
[01:29:30.881]                 removed <- setdiff(old_names, names)
[01:29:30.881]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:30.881]                   envs[common]]
[01:29:30.881]                 NAMES <- toupper(changed)
[01:29:30.881]                 args <- list()
[01:29:30.881]                 for (kk in seq_along(NAMES)) {
[01:29:30.881]                   name <- changed[[kk]]
[01:29:30.881]                   NAME <- NAMES[[kk]]
[01:29:30.881]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.881]                     next
[01:29:30.881]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.881]                 }
[01:29:30.881]                 NAMES <- toupper(added)
[01:29:30.881]                 for (kk in seq_along(NAMES)) {
[01:29:30.881]                   name <- added[[kk]]
[01:29:30.881]                   NAME <- NAMES[[kk]]
[01:29:30.881]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.881]                     next
[01:29:30.881]                   args[[name]] <- ""
[01:29:30.881]                 }
[01:29:30.881]                 NAMES <- toupper(removed)
[01:29:30.881]                 for (kk in seq_along(NAMES)) {
[01:29:30.881]                   name <- removed[[kk]]
[01:29:30.881]                   NAME <- NAMES[[kk]]
[01:29:30.881]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.881]                     next
[01:29:30.881]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.881]                 }
[01:29:30.881]                 if (length(args) > 0) 
[01:29:30.881]                   base::do.call(base::Sys.setenv, args = args)
[01:29:30.881]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:30.881]             }
[01:29:30.881]             else {
[01:29:30.881]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:30.881]             }
[01:29:30.881]             {
[01:29:30.881]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:30.881]                   0L) {
[01:29:30.881]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:30.881]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:30.881]                   base::options(opts)
[01:29:30.881]                 }
[01:29:30.881]                 {
[01:29:30.881]                   {
[01:29:30.881]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:30.881]                     NULL
[01:29:30.881]                   }
[01:29:30.881]                   options(future.plan = NULL)
[01:29:30.881]                   if (is.na(NA_character_)) 
[01:29:30.881]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.881]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:30.881]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:30.881]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:30.881]                     envir = parent.frame()) 
[01:29:30.881]                   {
[01:29:30.881]                     if (is.function(workers)) 
[01:29:30.881]                       workers <- workers()
[01:29:30.881]                     workers <- structure(as.integer(workers), 
[01:29:30.881]                       class = class(workers))
[01:29:30.881]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:30.881]                       workers >= 1)
[01:29:30.881]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:30.881]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:30.881]                     }
[01:29:30.881]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:30.881]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:30.881]                       envir = envir)
[01:29:30.881]                     if (!future$lazy) 
[01:29:30.881]                       future <- run(future)
[01:29:30.881]                     invisible(future)
[01:29:30.881]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:30.881]                 }
[01:29:30.881]             }
[01:29:30.881]         }
[01:29:30.881]     })
[01:29:30.881]     if (TRUE) {
[01:29:30.881]         base::sink(type = "output", split = FALSE)
[01:29:30.881]         if (TRUE) {
[01:29:30.881]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:30.881]         }
[01:29:30.881]         else {
[01:29:30.881]             ...future.result["stdout"] <- base::list(NULL)
[01:29:30.881]         }
[01:29:30.881]         base::close(...future.stdout)
[01:29:30.881]         ...future.stdout <- NULL
[01:29:30.881]     }
[01:29:30.881]     ...future.result$conditions <- ...future.conditions
[01:29:30.881]     ...future.result$finished <- base::Sys.time()
[01:29:30.881]     ...future.result
[01:29:30.881] }
[01:29:30.887] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:30.887] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:30.888] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:30.888] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:30.889] MultisessionFuture started
[01:29:30.889] - Launch lazy future ... done
[01:29:30.889] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_1-940921'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96cf2b3a8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[01:29:30.911] receiveMessageFromWorker() for ClusterFuture ...
[01:29:30.912] - Validating connection of MultisessionFuture
[01:29:30.912] - received message: FutureResult
[01:29:30.912] - Received FutureResult
[01:29:30.913] - Erased future from FutureRegistry
[01:29:30.913] result() for ClusterFuture ...
[01:29:30.913] - result already collected: FutureResult
[01:29:30.913] result() for ClusterFuture ... done
[01:29:30.913] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.914] getGlobalsAndPackages() ...
[01:29:30.914] Searching for globals...
[01:29:30.915] - globals found: [3] '{', 'sample', 'x'
[01:29:30.916] Searching for globals ... DONE
[01:29:30.916] Resolving globals: FALSE
[01:29:30.916] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:30.917] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:30.917] - globals: [1] 'x'
[01:29:30.917] 
[01:29:30.918] getGlobalsAndPackages() ... DONE
[01:29:30.918] run() for 'Future' ...
[01:29:30.918] - state: 'created'
[01:29:30.918] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:30.934] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.934] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:30.935]   - Field: 'node'
[01:29:30.935]   - Field: 'label'
[01:29:30.935]   - Field: 'local'
[01:29:30.935]   - Field: 'owner'
[01:29:30.936]   - Field: 'envir'
[01:29:30.936]   - Field: 'workers'
[01:29:30.936]   - Field: 'packages'
[01:29:30.936]   - Field: 'gc'
[01:29:30.937]   - Field: 'conditions'
[01:29:30.937]   - Field: 'persistent'
[01:29:30.937]   - Field: 'expr'
[01:29:30.937]   - Field: 'uuid'
[01:29:30.938]   - Field: 'seed'
[01:29:30.938]   - Field: 'version'
[01:29:30.938]   - Field: 'result'
[01:29:30.938]   - Field: 'asynchronous'
[01:29:30.939]   - Field: 'calls'
[01:29:30.939]   - Field: 'globals'
[01:29:30.939]   - Field: 'stdout'
[01:29:30.939]   - Field: 'earlySignal'
[01:29:30.940]   - Field: 'lazy'
[01:29:30.940]   - Field: 'state'
[01:29:30.940] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:30.940] - Launch lazy future ...
[01:29:30.941] Packages needed by the future expression (n = 0): <none>
[01:29:30.941] Packages needed by future strategies (n = 0): <none>
[01:29:30.942] {
[01:29:30.942]     {
[01:29:30.942]         {
[01:29:30.942]             ...future.startTime <- base::Sys.time()
[01:29:30.942]             {
[01:29:30.942]                 {
[01:29:30.942]                   {
[01:29:30.942]                     {
[01:29:30.942]                       base::local({
[01:29:30.942]                         has_future <- base::requireNamespace("future", 
[01:29:30.942]                           quietly = TRUE)
[01:29:30.942]                         if (has_future) {
[01:29:30.942]                           ns <- base::getNamespace("future")
[01:29:30.942]                           version <- ns[[".package"]][["version"]]
[01:29:30.942]                           if (is.null(version)) 
[01:29:30.942]                             version <- utils::packageVersion("future")
[01:29:30.942]                         }
[01:29:30.942]                         else {
[01:29:30.942]                           version <- NULL
[01:29:30.942]                         }
[01:29:30.942]                         if (!has_future || version < "1.8.0") {
[01:29:30.942]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:30.942]                             "", base::R.version$version.string), 
[01:29:30.942]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:30.942]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:30.942]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:30.942]                               "release", "version")], collapse = " "), 
[01:29:30.942]                             hostname = base::Sys.info()[["nodename"]])
[01:29:30.942]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:30.942]                             info)
[01:29:30.942]                           info <- base::paste(info, collapse = "; ")
[01:29:30.942]                           if (!has_future) {
[01:29:30.942]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:30.942]                               info)
[01:29:30.942]                           }
[01:29:30.942]                           else {
[01:29:30.942]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:30.942]                               info, version)
[01:29:30.942]                           }
[01:29:30.942]                           base::stop(msg)
[01:29:30.942]                         }
[01:29:30.942]                       })
[01:29:30.942]                     }
[01:29:30.942]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:30.942]                     base::options(mc.cores = 1L)
[01:29:30.942]                   }
[01:29:30.942]                   options(future.plan = NULL)
[01:29:30.942]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.942]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:30.942]                 }
[01:29:30.942]                 ...future.workdir <- getwd()
[01:29:30.942]             }
[01:29:30.942]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:30.942]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:30.942]         }
[01:29:30.942]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:30.942]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:30.942]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:30.942]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:30.942]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:30.942]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:30.942]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:30.942]             base::names(...future.oldOptions))
[01:29:30.942]     }
[01:29:30.942]     if (FALSE) {
[01:29:30.942]     }
[01:29:30.942]     else {
[01:29:30.942]         if (TRUE) {
[01:29:30.942]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:30.942]                 open = "w")
[01:29:30.942]         }
[01:29:30.942]         else {
[01:29:30.942]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:30.942]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:30.942]         }
[01:29:30.942]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:30.942]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:30.942]             base::sink(type = "output", split = FALSE)
[01:29:30.942]             base::close(...future.stdout)
[01:29:30.942]         }, add = TRUE)
[01:29:30.942]     }
[01:29:30.942]     ...future.frame <- base::sys.nframe()
[01:29:30.942]     ...future.conditions <- base::list()
[01:29:30.942]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:30.942]     if (FALSE) {
[01:29:30.942]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:30.942]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:30.942]     }
[01:29:30.942]     ...future.result <- base::tryCatch({
[01:29:30.942]         base::withCallingHandlers({
[01:29:30.942]             ...future.value <- base::withVisible(base::local({
[01:29:30.942]                 ...future.makeSendCondition <- base::local({
[01:29:30.942]                   sendCondition <- NULL
[01:29:30.942]                   function(frame = 1L) {
[01:29:30.942]                     if (is.function(sendCondition)) 
[01:29:30.942]                       return(sendCondition)
[01:29:30.942]                     ns <- getNamespace("parallel")
[01:29:30.942]                     if (exists("sendData", mode = "function", 
[01:29:30.942]                       envir = ns)) {
[01:29:30.942]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:30.942]                         envir = ns)
[01:29:30.942]                       envir <- sys.frame(frame)
[01:29:30.942]                       master <- NULL
[01:29:30.942]                       while (!identical(envir, .GlobalEnv) && 
[01:29:30.942]                         !identical(envir, emptyenv())) {
[01:29:30.942]                         if (exists("master", mode = "list", envir = envir, 
[01:29:30.942]                           inherits = FALSE)) {
[01:29:30.942]                           master <- get("master", mode = "list", 
[01:29:30.942]                             envir = envir, inherits = FALSE)
[01:29:30.942]                           if (inherits(master, c("SOCKnode", 
[01:29:30.942]                             "SOCK0node"))) {
[01:29:30.942]                             sendCondition <<- function(cond) {
[01:29:30.942]                               data <- list(type = "VALUE", value = cond, 
[01:29:30.942]                                 success = TRUE)
[01:29:30.942]                               parallel_sendData(master, data)
[01:29:30.942]                             }
[01:29:30.942]                             return(sendCondition)
[01:29:30.942]                           }
[01:29:30.942]                         }
[01:29:30.942]                         frame <- frame + 1L
[01:29:30.942]                         envir <- sys.frame(frame)
[01:29:30.942]                       }
[01:29:30.942]                     }
[01:29:30.942]                     sendCondition <<- function(cond) NULL
[01:29:30.942]                   }
[01:29:30.942]                 })
[01:29:30.942]                 withCallingHandlers({
[01:29:30.942]                   {
[01:29:30.942]                     sample(x, size = 1L)
[01:29:30.942]                   }
[01:29:30.942]                 }, immediateCondition = function(cond) {
[01:29:30.942]                   sendCondition <- ...future.makeSendCondition()
[01:29:30.942]                   sendCondition(cond)
[01:29:30.942]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.942]                   {
[01:29:30.942]                     inherits <- base::inherits
[01:29:30.942]                     invokeRestart <- base::invokeRestart
[01:29:30.942]                     is.null <- base::is.null
[01:29:30.942]                     muffled <- FALSE
[01:29:30.942]                     if (inherits(cond, "message")) {
[01:29:30.942]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:30.942]                       if (muffled) 
[01:29:30.942]                         invokeRestart("muffleMessage")
[01:29:30.942]                     }
[01:29:30.942]                     else if (inherits(cond, "warning")) {
[01:29:30.942]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:30.942]                       if (muffled) 
[01:29:30.942]                         invokeRestart("muffleWarning")
[01:29:30.942]                     }
[01:29:30.942]                     else if (inherits(cond, "condition")) {
[01:29:30.942]                       if (!is.null(pattern)) {
[01:29:30.942]                         computeRestarts <- base::computeRestarts
[01:29:30.942]                         grepl <- base::grepl
[01:29:30.942]                         restarts <- computeRestarts(cond)
[01:29:30.942]                         for (restart in restarts) {
[01:29:30.942]                           name <- restart$name
[01:29:30.942]                           if (is.null(name)) 
[01:29:30.942]                             next
[01:29:30.942]                           if (!grepl(pattern, name)) 
[01:29:30.942]                             next
[01:29:30.942]                           invokeRestart(restart)
[01:29:30.942]                           muffled <- TRUE
[01:29:30.942]                           break
[01:29:30.942]                         }
[01:29:30.942]                       }
[01:29:30.942]                     }
[01:29:30.942]                     invisible(muffled)
[01:29:30.942]                   }
[01:29:30.942]                   muffleCondition(cond)
[01:29:30.942]                 })
[01:29:30.942]             }))
[01:29:30.942]             future::FutureResult(value = ...future.value$value, 
[01:29:30.942]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.942]                   ...future.rng), globalenv = if (FALSE) 
[01:29:30.942]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:30.942]                     ...future.globalenv.names))
[01:29:30.942]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:30.942]         }, condition = base::local({
[01:29:30.942]             c <- base::c
[01:29:30.942]             inherits <- base::inherits
[01:29:30.942]             invokeRestart <- base::invokeRestart
[01:29:30.942]             length <- base::length
[01:29:30.942]             list <- base::list
[01:29:30.942]             seq.int <- base::seq.int
[01:29:30.942]             signalCondition <- base::signalCondition
[01:29:30.942]             sys.calls <- base::sys.calls
[01:29:30.942]             `[[` <- base::`[[`
[01:29:30.942]             `+` <- base::`+`
[01:29:30.942]             `<<-` <- base::`<<-`
[01:29:30.942]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:30.942]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:30.942]                   3L)]
[01:29:30.942]             }
[01:29:30.942]             function(cond) {
[01:29:30.942]                 is_error <- inherits(cond, "error")
[01:29:30.942]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:30.942]                   NULL)
[01:29:30.942]                 if (is_error) {
[01:29:30.942]                   sessionInformation <- function() {
[01:29:30.942]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:30.942]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:30.942]                       search = base::search(), system = base::Sys.info())
[01:29:30.942]                   }
[01:29:30.942]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.942]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:30.942]                     cond$call), session = sessionInformation(), 
[01:29:30.942]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:30.942]                   signalCondition(cond)
[01:29:30.942]                 }
[01:29:30.942]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:30.942]                 "immediateCondition"))) {
[01:29:30.942]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:30.942]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.942]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:30.942]                   if (TRUE && !signal) {
[01:29:30.942]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.942]                     {
[01:29:30.942]                       inherits <- base::inherits
[01:29:30.942]                       invokeRestart <- base::invokeRestart
[01:29:30.942]                       is.null <- base::is.null
[01:29:30.942]                       muffled <- FALSE
[01:29:30.942]                       if (inherits(cond, "message")) {
[01:29:30.942]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.942]                         if (muffled) 
[01:29:30.942]                           invokeRestart("muffleMessage")
[01:29:30.942]                       }
[01:29:30.942]                       else if (inherits(cond, "warning")) {
[01:29:30.942]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.942]                         if (muffled) 
[01:29:30.942]                           invokeRestart("muffleWarning")
[01:29:30.942]                       }
[01:29:30.942]                       else if (inherits(cond, "condition")) {
[01:29:30.942]                         if (!is.null(pattern)) {
[01:29:30.942]                           computeRestarts <- base::computeRestarts
[01:29:30.942]                           grepl <- base::grepl
[01:29:30.942]                           restarts <- computeRestarts(cond)
[01:29:30.942]                           for (restart in restarts) {
[01:29:30.942]                             name <- restart$name
[01:29:30.942]                             if (is.null(name)) 
[01:29:30.942]                               next
[01:29:30.942]                             if (!grepl(pattern, name)) 
[01:29:30.942]                               next
[01:29:30.942]                             invokeRestart(restart)
[01:29:30.942]                             muffled <- TRUE
[01:29:30.942]                             break
[01:29:30.942]                           }
[01:29:30.942]                         }
[01:29:30.942]                       }
[01:29:30.942]                       invisible(muffled)
[01:29:30.942]                     }
[01:29:30.942]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.942]                   }
[01:29:30.942]                 }
[01:29:30.942]                 else {
[01:29:30.942]                   if (TRUE) {
[01:29:30.942]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.942]                     {
[01:29:30.942]                       inherits <- base::inherits
[01:29:30.942]                       invokeRestart <- base::invokeRestart
[01:29:30.942]                       is.null <- base::is.null
[01:29:30.942]                       muffled <- FALSE
[01:29:30.942]                       if (inherits(cond, "message")) {
[01:29:30.942]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.942]                         if (muffled) 
[01:29:30.942]                           invokeRestart("muffleMessage")
[01:29:30.942]                       }
[01:29:30.942]                       else if (inherits(cond, "warning")) {
[01:29:30.942]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.942]                         if (muffled) 
[01:29:30.942]                           invokeRestart("muffleWarning")
[01:29:30.942]                       }
[01:29:30.942]                       else if (inherits(cond, "condition")) {
[01:29:30.942]                         if (!is.null(pattern)) {
[01:29:30.942]                           computeRestarts <- base::computeRestarts
[01:29:30.942]                           grepl <- base::grepl
[01:29:30.942]                           restarts <- computeRestarts(cond)
[01:29:30.942]                           for (restart in restarts) {
[01:29:30.942]                             name <- restart$name
[01:29:30.942]                             if (is.null(name)) 
[01:29:30.942]                               next
[01:29:30.942]                             if (!grepl(pattern, name)) 
[01:29:30.942]                               next
[01:29:30.942]                             invokeRestart(restart)
[01:29:30.942]                             muffled <- TRUE
[01:29:30.942]                             break
[01:29:30.942]                           }
[01:29:30.942]                         }
[01:29:30.942]                       }
[01:29:30.942]                       invisible(muffled)
[01:29:30.942]                     }
[01:29:30.942]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.942]                   }
[01:29:30.942]                 }
[01:29:30.942]             }
[01:29:30.942]         }))
[01:29:30.942]     }, error = function(ex) {
[01:29:30.942]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:30.942]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.942]                 ...future.rng), started = ...future.startTime, 
[01:29:30.942]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:30.942]             version = "1.8"), class = "FutureResult")
[01:29:30.942]     }, finally = {
[01:29:30.942]         if (!identical(...future.workdir, getwd())) 
[01:29:30.942]             setwd(...future.workdir)
[01:29:30.942]         {
[01:29:30.942]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:30.942]                 ...future.oldOptions$nwarnings <- NULL
[01:29:30.942]             }
[01:29:30.942]             base::options(...future.oldOptions)
[01:29:30.942]             if (.Platform$OS.type == "windows") {
[01:29:30.942]                 old_names <- names(...future.oldEnvVars)
[01:29:30.942]                 envs <- base::Sys.getenv()
[01:29:30.942]                 names <- names(envs)
[01:29:30.942]                 common <- intersect(names, old_names)
[01:29:30.942]                 added <- setdiff(names, old_names)
[01:29:30.942]                 removed <- setdiff(old_names, names)
[01:29:30.942]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:30.942]                   envs[common]]
[01:29:30.942]                 NAMES <- toupper(changed)
[01:29:30.942]                 args <- list()
[01:29:30.942]                 for (kk in seq_along(NAMES)) {
[01:29:30.942]                   name <- changed[[kk]]
[01:29:30.942]                   NAME <- NAMES[[kk]]
[01:29:30.942]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.942]                     next
[01:29:30.942]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.942]                 }
[01:29:30.942]                 NAMES <- toupper(added)
[01:29:30.942]                 for (kk in seq_along(NAMES)) {
[01:29:30.942]                   name <- added[[kk]]
[01:29:30.942]                   NAME <- NAMES[[kk]]
[01:29:30.942]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.942]                     next
[01:29:30.942]                   args[[name]] <- ""
[01:29:30.942]                 }
[01:29:30.942]                 NAMES <- toupper(removed)
[01:29:30.942]                 for (kk in seq_along(NAMES)) {
[01:29:30.942]                   name <- removed[[kk]]
[01:29:30.942]                   NAME <- NAMES[[kk]]
[01:29:30.942]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.942]                     next
[01:29:30.942]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.942]                 }
[01:29:30.942]                 if (length(args) > 0) 
[01:29:30.942]                   base::do.call(base::Sys.setenv, args = args)
[01:29:30.942]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:30.942]             }
[01:29:30.942]             else {
[01:29:30.942]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:30.942]             }
[01:29:30.942]             {
[01:29:30.942]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:30.942]                   0L) {
[01:29:30.942]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:30.942]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:30.942]                   base::options(opts)
[01:29:30.942]                 }
[01:29:30.942]                 {
[01:29:30.942]                   {
[01:29:30.942]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:30.942]                     NULL
[01:29:30.942]                   }
[01:29:30.942]                   options(future.plan = NULL)
[01:29:30.942]                   if (is.na(NA_character_)) 
[01:29:30.942]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.942]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:30.942]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:30.942]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:30.942]                     envir = parent.frame()) 
[01:29:30.942]                   {
[01:29:30.942]                     if (is.function(workers)) 
[01:29:30.942]                       workers <- workers()
[01:29:30.942]                     workers <- structure(as.integer(workers), 
[01:29:30.942]                       class = class(workers))
[01:29:30.942]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:30.942]                       workers >= 1)
[01:29:30.942]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:30.942]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:30.942]                     }
[01:29:30.942]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:30.942]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:30.942]                       envir = envir)
[01:29:30.942]                     if (!future$lazy) 
[01:29:30.942]                       future <- run(future)
[01:29:30.942]                     invisible(future)
[01:29:30.942]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:30.942]                 }
[01:29:30.942]             }
[01:29:30.942]         }
[01:29:30.942]     })
[01:29:30.942]     if (TRUE) {
[01:29:30.942]         base::sink(type = "output", split = FALSE)
[01:29:30.942]         if (TRUE) {
[01:29:30.942]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:30.942]         }
[01:29:30.942]         else {
[01:29:30.942]             ...future.result["stdout"] <- base::list(NULL)
[01:29:30.942]         }
[01:29:30.942]         base::close(...future.stdout)
[01:29:30.942]         ...future.stdout <- NULL
[01:29:30.942]     }
[01:29:30.942]     ...future.result$conditions <- ...future.conditions
[01:29:30.942]     ...future.result$finished <- base::Sys.time()
[01:29:30.942]     ...future.result
[01:29:30.942] }
[01:29:30.948] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:30.948] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:30.949] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:30.949] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:30.950] MultisessionFuture started
[01:29:30.950] - Launch lazy future ... done
[01:29:30.950] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_2-827958'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96cf2b3a8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[01:29:30.968] receiveMessageFromWorker() for ClusterFuture ...
[01:29:30.969] - Validating connection of MultisessionFuture
[01:29:30.969] - received message: FutureResult
[01:29:30.969] - Received FutureResult
[01:29:30.969] - Erased future from FutureRegistry
[01:29:30.970] result() for ClusterFuture ...
[01:29:30.970] - result already collected: FutureResult
[01:29:30.970] result() for ClusterFuture ... done
[01:29:30.970] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.971] getGlobalsAndPackages() ...
[01:29:30.971] Searching for globals...
[01:29:30.972] - globals found: [3] '{', 'sample', 'x'
[01:29:30.973] Searching for globals ... DONE
[01:29:30.973] Resolving globals: FALSE
[01:29:30.974] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:30.974] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:30.974] - globals: [1] 'x'
[01:29:30.975] 
[01:29:30.975] getGlobalsAndPackages() ... DONE
[01:29:30.975] run() for 'Future' ...
[01:29:30.975] - state: 'created'
[01:29:30.976] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:30.990] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:30.991] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:30.991]   - Field: 'node'
[01:29:30.991]   - Field: 'label'
[01:29:30.991]   - Field: 'local'
[01:29:30.991]   - Field: 'owner'
[01:29:30.992]   - Field: 'envir'
[01:29:30.992]   - Field: 'workers'
[01:29:30.992]   - Field: 'packages'
[01:29:30.992]   - Field: 'gc'
[01:29:30.992]   - Field: 'conditions'
[01:29:30.993]   - Field: 'persistent'
[01:29:30.993]   - Field: 'expr'
[01:29:30.993]   - Field: 'uuid'
[01:29:30.993]   - Field: 'seed'
[01:29:30.993]   - Field: 'version'
[01:29:30.993]   - Field: 'result'
[01:29:30.994]   - Field: 'asynchronous'
[01:29:30.994]   - Field: 'calls'
[01:29:30.994]   - Field: 'globals'
[01:29:30.994]   - Field: 'stdout'
[01:29:30.994]   - Field: 'earlySignal'
[01:29:30.995]   - Field: 'lazy'
[01:29:30.995]   - Field: 'state'
[01:29:30.995] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:30.995] - Launch lazy future ...
[01:29:30.995] Packages needed by the future expression (n = 0): <none>
[01:29:30.996] Packages needed by future strategies (n = 0): <none>
[01:29:30.996] {
[01:29:30.996]     {
[01:29:30.996]         {
[01:29:30.996]             ...future.startTime <- base::Sys.time()
[01:29:30.996]             {
[01:29:30.996]                 {
[01:29:30.996]                   {
[01:29:30.996]                     {
[01:29:30.996]                       base::local({
[01:29:30.996]                         has_future <- base::requireNamespace("future", 
[01:29:30.996]                           quietly = TRUE)
[01:29:30.996]                         if (has_future) {
[01:29:30.996]                           ns <- base::getNamespace("future")
[01:29:30.996]                           version <- ns[[".package"]][["version"]]
[01:29:30.996]                           if (is.null(version)) 
[01:29:30.996]                             version <- utils::packageVersion("future")
[01:29:30.996]                         }
[01:29:30.996]                         else {
[01:29:30.996]                           version <- NULL
[01:29:30.996]                         }
[01:29:30.996]                         if (!has_future || version < "1.8.0") {
[01:29:30.996]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:30.996]                             "", base::R.version$version.string), 
[01:29:30.996]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:30.996]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:30.996]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:30.996]                               "release", "version")], collapse = " "), 
[01:29:30.996]                             hostname = base::Sys.info()[["nodename"]])
[01:29:30.996]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:30.996]                             info)
[01:29:30.996]                           info <- base::paste(info, collapse = "; ")
[01:29:30.996]                           if (!has_future) {
[01:29:30.996]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:30.996]                               info)
[01:29:30.996]                           }
[01:29:30.996]                           else {
[01:29:30.996]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:30.996]                               info, version)
[01:29:30.996]                           }
[01:29:30.996]                           base::stop(msg)
[01:29:30.996]                         }
[01:29:30.996]                       })
[01:29:30.996]                     }
[01:29:30.996]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:30.996]                     base::options(mc.cores = 1L)
[01:29:30.996]                   }
[01:29:30.996]                   options(future.plan = NULL)
[01:29:30.996]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.996]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:30.996]                 }
[01:29:30.996]                 ...future.workdir <- getwd()
[01:29:30.996]             }
[01:29:30.996]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:30.996]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:30.996]         }
[01:29:30.996]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:30.996]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:30.996]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:30.996]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:30.996]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:30.996]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:30.996]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:30.996]             base::names(...future.oldOptions))
[01:29:30.996]     }
[01:29:30.996]     if (FALSE) {
[01:29:30.996]     }
[01:29:30.996]     else {
[01:29:30.996]         if (TRUE) {
[01:29:30.996]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:30.996]                 open = "w")
[01:29:30.996]         }
[01:29:30.996]         else {
[01:29:30.996]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:30.996]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:30.996]         }
[01:29:30.996]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:30.996]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:30.996]             base::sink(type = "output", split = FALSE)
[01:29:30.996]             base::close(...future.stdout)
[01:29:30.996]         }, add = TRUE)
[01:29:30.996]     }
[01:29:30.996]     ...future.frame <- base::sys.nframe()
[01:29:30.996]     ...future.conditions <- base::list()
[01:29:30.996]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:30.996]     if (FALSE) {
[01:29:30.996]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:30.996]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:30.996]     }
[01:29:30.996]     ...future.result <- base::tryCatch({
[01:29:30.996]         base::withCallingHandlers({
[01:29:30.996]             ...future.value <- base::withVisible(base::local({
[01:29:30.996]                 ...future.makeSendCondition <- base::local({
[01:29:30.996]                   sendCondition <- NULL
[01:29:30.996]                   function(frame = 1L) {
[01:29:30.996]                     if (is.function(sendCondition)) 
[01:29:30.996]                       return(sendCondition)
[01:29:30.996]                     ns <- getNamespace("parallel")
[01:29:30.996]                     if (exists("sendData", mode = "function", 
[01:29:30.996]                       envir = ns)) {
[01:29:30.996]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:30.996]                         envir = ns)
[01:29:30.996]                       envir <- sys.frame(frame)
[01:29:30.996]                       master <- NULL
[01:29:30.996]                       while (!identical(envir, .GlobalEnv) && 
[01:29:30.996]                         !identical(envir, emptyenv())) {
[01:29:30.996]                         if (exists("master", mode = "list", envir = envir, 
[01:29:30.996]                           inherits = FALSE)) {
[01:29:30.996]                           master <- get("master", mode = "list", 
[01:29:30.996]                             envir = envir, inherits = FALSE)
[01:29:30.996]                           if (inherits(master, c("SOCKnode", 
[01:29:30.996]                             "SOCK0node"))) {
[01:29:30.996]                             sendCondition <<- function(cond) {
[01:29:30.996]                               data <- list(type = "VALUE", value = cond, 
[01:29:30.996]                                 success = TRUE)
[01:29:30.996]                               parallel_sendData(master, data)
[01:29:30.996]                             }
[01:29:30.996]                             return(sendCondition)
[01:29:30.996]                           }
[01:29:30.996]                         }
[01:29:30.996]                         frame <- frame + 1L
[01:29:30.996]                         envir <- sys.frame(frame)
[01:29:30.996]                       }
[01:29:30.996]                     }
[01:29:30.996]                     sendCondition <<- function(cond) NULL
[01:29:30.996]                   }
[01:29:30.996]                 })
[01:29:30.996]                 withCallingHandlers({
[01:29:30.996]                   {
[01:29:30.996]                     sample(x, size = 1L)
[01:29:30.996]                   }
[01:29:30.996]                 }, immediateCondition = function(cond) {
[01:29:30.996]                   sendCondition <- ...future.makeSendCondition()
[01:29:30.996]                   sendCondition(cond)
[01:29:30.996]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.996]                   {
[01:29:30.996]                     inherits <- base::inherits
[01:29:30.996]                     invokeRestart <- base::invokeRestart
[01:29:30.996]                     is.null <- base::is.null
[01:29:30.996]                     muffled <- FALSE
[01:29:30.996]                     if (inherits(cond, "message")) {
[01:29:30.996]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:30.996]                       if (muffled) 
[01:29:30.996]                         invokeRestart("muffleMessage")
[01:29:30.996]                     }
[01:29:30.996]                     else if (inherits(cond, "warning")) {
[01:29:30.996]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:30.996]                       if (muffled) 
[01:29:30.996]                         invokeRestart("muffleWarning")
[01:29:30.996]                     }
[01:29:30.996]                     else if (inherits(cond, "condition")) {
[01:29:30.996]                       if (!is.null(pattern)) {
[01:29:30.996]                         computeRestarts <- base::computeRestarts
[01:29:30.996]                         grepl <- base::grepl
[01:29:30.996]                         restarts <- computeRestarts(cond)
[01:29:30.996]                         for (restart in restarts) {
[01:29:30.996]                           name <- restart$name
[01:29:30.996]                           if (is.null(name)) 
[01:29:30.996]                             next
[01:29:30.996]                           if (!grepl(pattern, name)) 
[01:29:30.996]                             next
[01:29:30.996]                           invokeRestart(restart)
[01:29:30.996]                           muffled <- TRUE
[01:29:30.996]                           break
[01:29:30.996]                         }
[01:29:30.996]                       }
[01:29:30.996]                     }
[01:29:30.996]                     invisible(muffled)
[01:29:30.996]                   }
[01:29:30.996]                   muffleCondition(cond)
[01:29:30.996]                 })
[01:29:30.996]             }))
[01:29:30.996]             future::FutureResult(value = ...future.value$value, 
[01:29:30.996]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.996]                   ...future.rng), globalenv = if (FALSE) 
[01:29:30.996]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:30.996]                     ...future.globalenv.names))
[01:29:30.996]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:30.996]         }, condition = base::local({
[01:29:30.996]             c <- base::c
[01:29:30.996]             inherits <- base::inherits
[01:29:30.996]             invokeRestart <- base::invokeRestart
[01:29:30.996]             length <- base::length
[01:29:30.996]             list <- base::list
[01:29:30.996]             seq.int <- base::seq.int
[01:29:30.996]             signalCondition <- base::signalCondition
[01:29:30.996]             sys.calls <- base::sys.calls
[01:29:30.996]             `[[` <- base::`[[`
[01:29:30.996]             `+` <- base::`+`
[01:29:30.996]             `<<-` <- base::`<<-`
[01:29:30.996]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:30.996]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:30.996]                   3L)]
[01:29:30.996]             }
[01:29:30.996]             function(cond) {
[01:29:30.996]                 is_error <- inherits(cond, "error")
[01:29:30.996]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:30.996]                   NULL)
[01:29:30.996]                 if (is_error) {
[01:29:30.996]                   sessionInformation <- function() {
[01:29:30.996]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:30.996]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:30.996]                       search = base::search(), system = base::Sys.info())
[01:29:30.996]                   }
[01:29:30.996]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.996]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:30.996]                     cond$call), session = sessionInformation(), 
[01:29:30.996]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:30.996]                   signalCondition(cond)
[01:29:30.996]                 }
[01:29:30.996]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:30.996]                 "immediateCondition"))) {
[01:29:30.996]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:30.996]                   ...future.conditions[[length(...future.conditions) + 
[01:29:30.996]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:30.996]                   if (TRUE && !signal) {
[01:29:30.996]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.996]                     {
[01:29:30.996]                       inherits <- base::inherits
[01:29:30.996]                       invokeRestart <- base::invokeRestart
[01:29:30.996]                       is.null <- base::is.null
[01:29:30.996]                       muffled <- FALSE
[01:29:30.996]                       if (inherits(cond, "message")) {
[01:29:30.996]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.996]                         if (muffled) 
[01:29:30.996]                           invokeRestart("muffleMessage")
[01:29:30.996]                       }
[01:29:30.996]                       else if (inherits(cond, "warning")) {
[01:29:30.996]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.996]                         if (muffled) 
[01:29:30.996]                           invokeRestart("muffleWarning")
[01:29:30.996]                       }
[01:29:30.996]                       else if (inherits(cond, "condition")) {
[01:29:30.996]                         if (!is.null(pattern)) {
[01:29:30.996]                           computeRestarts <- base::computeRestarts
[01:29:30.996]                           grepl <- base::grepl
[01:29:30.996]                           restarts <- computeRestarts(cond)
[01:29:30.996]                           for (restart in restarts) {
[01:29:30.996]                             name <- restart$name
[01:29:30.996]                             if (is.null(name)) 
[01:29:30.996]                               next
[01:29:30.996]                             if (!grepl(pattern, name)) 
[01:29:30.996]                               next
[01:29:30.996]                             invokeRestart(restart)
[01:29:30.996]                             muffled <- TRUE
[01:29:30.996]                             break
[01:29:30.996]                           }
[01:29:30.996]                         }
[01:29:30.996]                       }
[01:29:30.996]                       invisible(muffled)
[01:29:30.996]                     }
[01:29:30.996]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.996]                   }
[01:29:30.996]                 }
[01:29:30.996]                 else {
[01:29:30.996]                   if (TRUE) {
[01:29:30.996]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:30.996]                     {
[01:29:30.996]                       inherits <- base::inherits
[01:29:30.996]                       invokeRestart <- base::invokeRestart
[01:29:30.996]                       is.null <- base::is.null
[01:29:30.996]                       muffled <- FALSE
[01:29:30.996]                       if (inherits(cond, "message")) {
[01:29:30.996]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:30.996]                         if (muffled) 
[01:29:30.996]                           invokeRestart("muffleMessage")
[01:29:30.996]                       }
[01:29:30.996]                       else if (inherits(cond, "warning")) {
[01:29:30.996]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:30.996]                         if (muffled) 
[01:29:30.996]                           invokeRestart("muffleWarning")
[01:29:30.996]                       }
[01:29:30.996]                       else if (inherits(cond, "condition")) {
[01:29:30.996]                         if (!is.null(pattern)) {
[01:29:30.996]                           computeRestarts <- base::computeRestarts
[01:29:30.996]                           grepl <- base::grepl
[01:29:30.996]                           restarts <- computeRestarts(cond)
[01:29:30.996]                           for (restart in restarts) {
[01:29:30.996]                             name <- restart$name
[01:29:30.996]                             if (is.null(name)) 
[01:29:30.996]                               next
[01:29:30.996]                             if (!grepl(pattern, name)) 
[01:29:30.996]                               next
[01:29:30.996]                             invokeRestart(restart)
[01:29:30.996]                             muffled <- TRUE
[01:29:30.996]                             break
[01:29:30.996]                           }
[01:29:30.996]                         }
[01:29:30.996]                       }
[01:29:30.996]                       invisible(muffled)
[01:29:30.996]                     }
[01:29:30.996]                     muffleCondition(cond, pattern = "^muffle")
[01:29:30.996]                   }
[01:29:30.996]                 }
[01:29:30.996]             }
[01:29:30.996]         }))
[01:29:30.996]     }, error = function(ex) {
[01:29:30.996]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:30.996]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:30.996]                 ...future.rng), started = ...future.startTime, 
[01:29:30.996]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:30.996]             version = "1.8"), class = "FutureResult")
[01:29:30.996]     }, finally = {
[01:29:30.996]         if (!identical(...future.workdir, getwd())) 
[01:29:30.996]             setwd(...future.workdir)
[01:29:30.996]         {
[01:29:30.996]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:30.996]                 ...future.oldOptions$nwarnings <- NULL
[01:29:30.996]             }
[01:29:30.996]             base::options(...future.oldOptions)
[01:29:30.996]             if (.Platform$OS.type == "windows") {
[01:29:30.996]                 old_names <- names(...future.oldEnvVars)
[01:29:30.996]                 envs <- base::Sys.getenv()
[01:29:30.996]                 names <- names(envs)
[01:29:30.996]                 common <- intersect(names, old_names)
[01:29:30.996]                 added <- setdiff(names, old_names)
[01:29:30.996]                 removed <- setdiff(old_names, names)
[01:29:30.996]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:30.996]                   envs[common]]
[01:29:30.996]                 NAMES <- toupper(changed)
[01:29:30.996]                 args <- list()
[01:29:30.996]                 for (kk in seq_along(NAMES)) {
[01:29:30.996]                   name <- changed[[kk]]
[01:29:30.996]                   NAME <- NAMES[[kk]]
[01:29:30.996]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.996]                     next
[01:29:30.996]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.996]                 }
[01:29:30.996]                 NAMES <- toupper(added)
[01:29:30.996]                 for (kk in seq_along(NAMES)) {
[01:29:30.996]                   name <- added[[kk]]
[01:29:30.996]                   NAME <- NAMES[[kk]]
[01:29:30.996]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.996]                     next
[01:29:30.996]                   args[[name]] <- ""
[01:29:30.996]                 }
[01:29:30.996]                 NAMES <- toupper(removed)
[01:29:30.996]                 for (kk in seq_along(NAMES)) {
[01:29:30.996]                   name <- removed[[kk]]
[01:29:30.996]                   NAME <- NAMES[[kk]]
[01:29:30.996]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:30.996]                     next
[01:29:30.996]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:30.996]                 }
[01:29:30.996]                 if (length(args) > 0) 
[01:29:30.996]                   base::do.call(base::Sys.setenv, args = args)
[01:29:30.996]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:30.996]             }
[01:29:30.996]             else {
[01:29:30.996]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:30.996]             }
[01:29:30.996]             {
[01:29:30.996]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:30.996]                   0L) {
[01:29:30.996]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:30.996]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:30.996]                   base::options(opts)
[01:29:30.996]                 }
[01:29:30.996]                 {
[01:29:30.996]                   {
[01:29:30.996]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:30.996]                     NULL
[01:29:30.996]                   }
[01:29:30.996]                   options(future.plan = NULL)
[01:29:30.996]                   if (is.na(NA_character_)) 
[01:29:30.996]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:30.996]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:30.996]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:30.996]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:30.996]                     envir = parent.frame()) 
[01:29:30.996]                   {
[01:29:30.996]                     if (is.function(workers)) 
[01:29:30.996]                       workers <- workers()
[01:29:30.996]                     workers <- structure(as.integer(workers), 
[01:29:30.996]                       class = class(workers))
[01:29:30.996]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:30.996]                       workers >= 1)
[01:29:30.996]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:30.996]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:30.996]                     }
[01:29:30.996]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:30.996]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:30.996]                       envir = envir)
[01:29:30.996]                     if (!future$lazy) 
[01:29:30.996]                       future <- run(future)
[01:29:30.996]                     invisible(future)
[01:29:30.996]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:30.996]                 }
[01:29:30.996]             }
[01:29:30.996]         }
[01:29:30.996]     })
[01:29:30.996]     if (TRUE) {
[01:29:30.996]         base::sink(type = "output", split = FALSE)
[01:29:30.996]         if (TRUE) {
[01:29:30.996]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:30.996]         }
[01:29:30.996]         else {
[01:29:30.996]             ...future.result["stdout"] <- base::list(NULL)
[01:29:30.996]         }
[01:29:30.996]         base::close(...future.stdout)
[01:29:30.996]         ...future.stdout <- NULL
[01:29:30.996]     }
[01:29:30.996]     ...future.result$conditions <- ...future.conditions
[01:29:30.996]     ...future.result$finished <- base::Sys.time()
[01:29:30.996]     ...future.result
[01:29:30.996] }
[01:29:31.002] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:31.002] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:31.002] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:31.003] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:31.003] MultisessionFuture started
[01:29:31.004] - Launch lazy future ... done
[01:29:31.004] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_3-924329'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96cf2b3a8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[01:29:31.020] receiveMessageFromWorker() for ClusterFuture ...
[01:29:31.020] - Validating connection of MultisessionFuture
[01:29:31.020] - received message: FutureResult
[01:29:31.021] - Received FutureResult
[01:29:31.021] - Erased future from FutureRegistry
[01:29:31.021] result() for ClusterFuture ...
[01:29:31.021] - result already collected: FutureResult
[01:29:31.021] result() for ClusterFuture ... done
[01:29:31.021] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.022] getGlobalsAndPackages() ...
[01:29:31.022] Searching for globals...
[01:29:31.023] - globals found: [3] '{', 'sample', 'x'
[01:29:31.023] Searching for globals ... DONE
[01:29:31.023] Resolving globals: FALSE
[01:29:31.024] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:31.024] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:31.025] - globals: [1] 'x'
[01:29:31.025] 
[01:29:31.025] getGlobalsAndPackages() ... DONE
[01:29:31.025] run() for 'Future' ...
[01:29:31.025] - state: 'created'
[01:29:31.026] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:31.040] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.040] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:31.040]   - Field: 'node'
[01:29:31.040]   - Field: 'label'
[01:29:31.041]   - Field: 'local'
[01:29:31.041]   - Field: 'owner'
[01:29:31.041]   - Field: 'envir'
[01:29:31.041]   - Field: 'workers'
[01:29:31.041]   - Field: 'packages'
[01:29:31.042]   - Field: 'gc'
[01:29:31.042]   - Field: 'conditions'
[01:29:31.042]   - Field: 'persistent'
[01:29:31.042]   - Field: 'expr'
[01:29:31.042]   - Field: 'uuid'
[01:29:31.042]   - Field: 'seed'
[01:29:31.043]   - Field: 'version'
[01:29:31.043]   - Field: 'result'
[01:29:31.043]   - Field: 'asynchronous'
[01:29:31.043]   - Field: 'calls'
[01:29:31.043]   - Field: 'globals'
[01:29:31.044]   - Field: 'stdout'
[01:29:31.044]   - Field: 'earlySignal'
[01:29:31.044]   - Field: 'lazy'
[01:29:31.044]   - Field: 'state'
[01:29:31.044] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:31.044] - Launch lazy future ...
[01:29:31.045] Packages needed by the future expression (n = 0): <none>
[01:29:31.045] Packages needed by future strategies (n = 0): <none>
[01:29:31.046] {
[01:29:31.046]     {
[01:29:31.046]         {
[01:29:31.046]             ...future.startTime <- base::Sys.time()
[01:29:31.046]             {
[01:29:31.046]                 {
[01:29:31.046]                   {
[01:29:31.046]                     {
[01:29:31.046]                       base::local({
[01:29:31.046]                         has_future <- base::requireNamespace("future", 
[01:29:31.046]                           quietly = TRUE)
[01:29:31.046]                         if (has_future) {
[01:29:31.046]                           ns <- base::getNamespace("future")
[01:29:31.046]                           version <- ns[[".package"]][["version"]]
[01:29:31.046]                           if (is.null(version)) 
[01:29:31.046]                             version <- utils::packageVersion("future")
[01:29:31.046]                         }
[01:29:31.046]                         else {
[01:29:31.046]                           version <- NULL
[01:29:31.046]                         }
[01:29:31.046]                         if (!has_future || version < "1.8.0") {
[01:29:31.046]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:31.046]                             "", base::R.version$version.string), 
[01:29:31.046]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:31.046]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:31.046]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:31.046]                               "release", "version")], collapse = " "), 
[01:29:31.046]                             hostname = base::Sys.info()[["nodename"]])
[01:29:31.046]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:31.046]                             info)
[01:29:31.046]                           info <- base::paste(info, collapse = "; ")
[01:29:31.046]                           if (!has_future) {
[01:29:31.046]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:31.046]                               info)
[01:29:31.046]                           }
[01:29:31.046]                           else {
[01:29:31.046]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:31.046]                               info, version)
[01:29:31.046]                           }
[01:29:31.046]                           base::stop(msg)
[01:29:31.046]                         }
[01:29:31.046]                       })
[01:29:31.046]                     }
[01:29:31.046]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:31.046]                     base::options(mc.cores = 1L)
[01:29:31.046]                   }
[01:29:31.046]                   options(future.plan = NULL)
[01:29:31.046]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.046]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:31.046]                 }
[01:29:31.046]                 ...future.workdir <- getwd()
[01:29:31.046]             }
[01:29:31.046]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:31.046]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:31.046]         }
[01:29:31.046]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:31.046]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:31.046]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:31.046]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:31.046]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:31.046]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:31.046]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:31.046]             base::names(...future.oldOptions))
[01:29:31.046]     }
[01:29:31.046]     if (FALSE) {
[01:29:31.046]     }
[01:29:31.046]     else {
[01:29:31.046]         if (TRUE) {
[01:29:31.046]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:31.046]                 open = "w")
[01:29:31.046]         }
[01:29:31.046]         else {
[01:29:31.046]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:31.046]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:31.046]         }
[01:29:31.046]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:31.046]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:31.046]             base::sink(type = "output", split = FALSE)
[01:29:31.046]             base::close(...future.stdout)
[01:29:31.046]         }, add = TRUE)
[01:29:31.046]     }
[01:29:31.046]     ...future.frame <- base::sys.nframe()
[01:29:31.046]     ...future.conditions <- base::list()
[01:29:31.046]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:31.046]     if (FALSE) {
[01:29:31.046]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:31.046]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:31.046]     }
[01:29:31.046]     ...future.result <- base::tryCatch({
[01:29:31.046]         base::withCallingHandlers({
[01:29:31.046]             ...future.value <- base::withVisible(base::local({
[01:29:31.046]                 ...future.makeSendCondition <- base::local({
[01:29:31.046]                   sendCondition <- NULL
[01:29:31.046]                   function(frame = 1L) {
[01:29:31.046]                     if (is.function(sendCondition)) 
[01:29:31.046]                       return(sendCondition)
[01:29:31.046]                     ns <- getNamespace("parallel")
[01:29:31.046]                     if (exists("sendData", mode = "function", 
[01:29:31.046]                       envir = ns)) {
[01:29:31.046]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:31.046]                         envir = ns)
[01:29:31.046]                       envir <- sys.frame(frame)
[01:29:31.046]                       master <- NULL
[01:29:31.046]                       while (!identical(envir, .GlobalEnv) && 
[01:29:31.046]                         !identical(envir, emptyenv())) {
[01:29:31.046]                         if (exists("master", mode = "list", envir = envir, 
[01:29:31.046]                           inherits = FALSE)) {
[01:29:31.046]                           master <- get("master", mode = "list", 
[01:29:31.046]                             envir = envir, inherits = FALSE)
[01:29:31.046]                           if (inherits(master, c("SOCKnode", 
[01:29:31.046]                             "SOCK0node"))) {
[01:29:31.046]                             sendCondition <<- function(cond) {
[01:29:31.046]                               data <- list(type = "VALUE", value = cond, 
[01:29:31.046]                                 success = TRUE)
[01:29:31.046]                               parallel_sendData(master, data)
[01:29:31.046]                             }
[01:29:31.046]                             return(sendCondition)
[01:29:31.046]                           }
[01:29:31.046]                         }
[01:29:31.046]                         frame <- frame + 1L
[01:29:31.046]                         envir <- sys.frame(frame)
[01:29:31.046]                       }
[01:29:31.046]                     }
[01:29:31.046]                     sendCondition <<- function(cond) NULL
[01:29:31.046]                   }
[01:29:31.046]                 })
[01:29:31.046]                 withCallingHandlers({
[01:29:31.046]                   {
[01:29:31.046]                     sample(x, size = 1L)
[01:29:31.046]                   }
[01:29:31.046]                 }, immediateCondition = function(cond) {
[01:29:31.046]                   sendCondition <- ...future.makeSendCondition()
[01:29:31.046]                   sendCondition(cond)
[01:29:31.046]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.046]                   {
[01:29:31.046]                     inherits <- base::inherits
[01:29:31.046]                     invokeRestart <- base::invokeRestart
[01:29:31.046]                     is.null <- base::is.null
[01:29:31.046]                     muffled <- FALSE
[01:29:31.046]                     if (inherits(cond, "message")) {
[01:29:31.046]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:31.046]                       if (muffled) 
[01:29:31.046]                         invokeRestart("muffleMessage")
[01:29:31.046]                     }
[01:29:31.046]                     else if (inherits(cond, "warning")) {
[01:29:31.046]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:31.046]                       if (muffled) 
[01:29:31.046]                         invokeRestart("muffleWarning")
[01:29:31.046]                     }
[01:29:31.046]                     else if (inherits(cond, "condition")) {
[01:29:31.046]                       if (!is.null(pattern)) {
[01:29:31.046]                         computeRestarts <- base::computeRestarts
[01:29:31.046]                         grepl <- base::grepl
[01:29:31.046]                         restarts <- computeRestarts(cond)
[01:29:31.046]                         for (restart in restarts) {
[01:29:31.046]                           name <- restart$name
[01:29:31.046]                           if (is.null(name)) 
[01:29:31.046]                             next
[01:29:31.046]                           if (!grepl(pattern, name)) 
[01:29:31.046]                             next
[01:29:31.046]                           invokeRestart(restart)
[01:29:31.046]                           muffled <- TRUE
[01:29:31.046]                           break
[01:29:31.046]                         }
[01:29:31.046]                       }
[01:29:31.046]                     }
[01:29:31.046]                     invisible(muffled)
[01:29:31.046]                   }
[01:29:31.046]                   muffleCondition(cond)
[01:29:31.046]                 })
[01:29:31.046]             }))
[01:29:31.046]             future::FutureResult(value = ...future.value$value, 
[01:29:31.046]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.046]                   ...future.rng), globalenv = if (FALSE) 
[01:29:31.046]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:31.046]                     ...future.globalenv.names))
[01:29:31.046]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:31.046]         }, condition = base::local({
[01:29:31.046]             c <- base::c
[01:29:31.046]             inherits <- base::inherits
[01:29:31.046]             invokeRestart <- base::invokeRestart
[01:29:31.046]             length <- base::length
[01:29:31.046]             list <- base::list
[01:29:31.046]             seq.int <- base::seq.int
[01:29:31.046]             signalCondition <- base::signalCondition
[01:29:31.046]             sys.calls <- base::sys.calls
[01:29:31.046]             `[[` <- base::`[[`
[01:29:31.046]             `+` <- base::`+`
[01:29:31.046]             `<<-` <- base::`<<-`
[01:29:31.046]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:31.046]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:31.046]                   3L)]
[01:29:31.046]             }
[01:29:31.046]             function(cond) {
[01:29:31.046]                 is_error <- inherits(cond, "error")
[01:29:31.046]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:31.046]                   NULL)
[01:29:31.046]                 if (is_error) {
[01:29:31.046]                   sessionInformation <- function() {
[01:29:31.046]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:31.046]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:31.046]                       search = base::search(), system = base::Sys.info())
[01:29:31.046]                   }
[01:29:31.046]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.046]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:31.046]                     cond$call), session = sessionInformation(), 
[01:29:31.046]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:31.046]                   signalCondition(cond)
[01:29:31.046]                 }
[01:29:31.046]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:31.046]                 "immediateCondition"))) {
[01:29:31.046]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:31.046]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.046]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:31.046]                   if (TRUE && !signal) {
[01:29:31.046]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.046]                     {
[01:29:31.046]                       inherits <- base::inherits
[01:29:31.046]                       invokeRestart <- base::invokeRestart
[01:29:31.046]                       is.null <- base::is.null
[01:29:31.046]                       muffled <- FALSE
[01:29:31.046]                       if (inherits(cond, "message")) {
[01:29:31.046]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.046]                         if (muffled) 
[01:29:31.046]                           invokeRestart("muffleMessage")
[01:29:31.046]                       }
[01:29:31.046]                       else if (inherits(cond, "warning")) {
[01:29:31.046]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.046]                         if (muffled) 
[01:29:31.046]                           invokeRestart("muffleWarning")
[01:29:31.046]                       }
[01:29:31.046]                       else if (inherits(cond, "condition")) {
[01:29:31.046]                         if (!is.null(pattern)) {
[01:29:31.046]                           computeRestarts <- base::computeRestarts
[01:29:31.046]                           grepl <- base::grepl
[01:29:31.046]                           restarts <- computeRestarts(cond)
[01:29:31.046]                           for (restart in restarts) {
[01:29:31.046]                             name <- restart$name
[01:29:31.046]                             if (is.null(name)) 
[01:29:31.046]                               next
[01:29:31.046]                             if (!grepl(pattern, name)) 
[01:29:31.046]                               next
[01:29:31.046]                             invokeRestart(restart)
[01:29:31.046]                             muffled <- TRUE
[01:29:31.046]                             break
[01:29:31.046]                           }
[01:29:31.046]                         }
[01:29:31.046]                       }
[01:29:31.046]                       invisible(muffled)
[01:29:31.046]                     }
[01:29:31.046]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.046]                   }
[01:29:31.046]                 }
[01:29:31.046]                 else {
[01:29:31.046]                   if (TRUE) {
[01:29:31.046]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.046]                     {
[01:29:31.046]                       inherits <- base::inherits
[01:29:31.046]                       invokeRestart <- base::invokeRestart
[01:29:31.046]                       is.null <- base::is.null
[01:29:31.046]                       muffled <- FALSE
[01:29:31.046]                       if (inherits(cond, "message")) {
[01:29:31.046]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.046]                         if (muffled) 
[01:29:31.046]                           invokeRestart("muffleMessage")
[01:29:31.046]                       }
[01:29:31.046]                       else if (inherits(cond, "warning")) {
[01:29:31.046]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.046]                         if (muffled) 
[01:29:31.046]                           invokeRestart("muffleWarning")
[01:29:31.046]                       }
[01:29:31.046]                       else if (inherits(cond, "condition")) {
[01:29:31.046]                         if (!is.null(pattern)) {
[01:29:31.046]                           computeRestarts <- base::computeRestarts
[01:29:31.046]                           grepl <- base::grepl
[01:29:31.046]                           restarts <- computeRestarts(cond)
[01:29:31.046]                           for (restart in restarts) {
[01:29:31.046]                             name <- restart$name
[01:29:31.046]                             if (is.null(name)) 
[01:29:31.046]                               next
[01:29:31.046]                             if (!grepl(pattern, name)) 
[01:29:31.046]                               next
[01:29:31.046]                             invokeRestart(restart)
[01:29:31.046]                             muffled <- TRUE
[01:29:31.046]                             break
[01:29:31.046]                           }
[01:29:31.046]                         }
[01:29:31.046]                       }
[01:29:31.046]                       invisible(muffled)
[01:29:31.046]                     }
[01:29:31.046]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.046]                   }
[01:29:31.046]                 }
[01:29:31.046]             }
[01:29:31.046]         }))
[01:29:31.046]     }, error = function(ex) {
[01:29:31.046]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:31.046]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.046]                 ...future.rng), started = ...future.startTime, 
[01:29:31.046]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:31.046]             version = "1.8"), class = "FutureResult")
[01:29:31.046]     }, finally = {
[01:29:31.046]         if (!identical(...future.workdir, getwd())) 
[01:29:31.046]             setwd(...future.workdir)
[01:29:31.046]         {
[01:29:31.046]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:31.046]                 ...future.oldOptions$nwarnings <- NULL
[01:29:31.046]             }
[01:29:31.046]             base::options(...future.oldOptions)
[01:29:31.046]             if (.Platform$OS.type == "windows") {
[01:29:31.046]                 old_names <- names(...future.oldEnvVars)
[01:29:31.046]                 envs <- base::Sys.getenv()
[01:29:31.046]                 names <- names(envs)
[01:29:31.046]                 common <- intersect(names, old_names)
[01:29:31.046]                 added <- setdiff(names, old_names)
[01:29:31.046]                 removed <- setdiff(old_names, names)
[01:29:31.046]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:31.046]                   envs[common]]
[01:29:31.046]                 NAMES <- toupper(changed)
[01:29:31.046]                 args <- list()
[01:29:31.046]                 for (kk in seq_along(NAMES)) {
[01:29:31.046]                   name <- changed[[kk]]
[01:29:31.046]                   NAME <- NAMES[[kk]]
[01:29:31.046]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.046]                     next
[01:29:31.046]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.046]                 }
[01:29:31.046]                 NAMES <- toupper(added)
[01:29:31.046]                 for (kk in seq_along(NAMES)) {
[01:29:31.046]                   name <- added[[kk]]
[01:29:31.046]                   NAME <- NAMES[[kk]]
[01:29:31.046]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.046]                     next
[01:29:31.046]                   args[[name]] <- ""
[01:29:31.046]                 }
[01:29:31.046]                 NAMES <- toupper(removed)
[01:29:31.046]                 for (kk in seq_along(NAMES)) {
[01:29:31.046]                   name <- removed[[kk]]
[01:29:31.046]                   NAME <- NAMES[[kk]]
[01:29:31.046]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.046]                     next
[01:29:31.046]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.046]                 }
[01:29:31.046]                 if (length(args) > 0) 
[01:29:31.046]                   base::do.call(base::Sys.setenv, args = args)
[01:29:31.046]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:31.046]             }
[01:29:31.046]             else {
[01:29:31.046]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:31.046]             }
[01:29:31.046]             {
[01:29:31.046]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:31.046]                   0L) {
[01:29:31.046]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:31.046]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:31.046]                   base::options(opts)
[01:29:31.046]                 }
[01:29:31.046]                 {
[01:29:31.046]                   {
[01:29:31.046]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:31.046]                     NULL
[01:29:31.046]                   }
[01:29:31.046]                   options(future.plan = NULL)
[01:29:31.046]                   if (is.na(NA_character_)) 
[01:29:31.046]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.046]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:31.046]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:31.046]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:31.046]                     envir = parent.frame()) 
[01:29:31.046]                   {
[01:29:31.046]                     if (is.function(workers)) 
[01:29:31.046]                       workers <- workers()
[01:29:31.046]                     workers <- structure(as.integer(workers), 
[01:29:31.046]                       class = class(workers))
[01:29:31.046]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:31.046]                       workers >= 1)
[01:29:31.046]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:31.046]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:31.046]                     }
[01:29:31.046]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:31.046]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:31.046]                       envir = envir)
[01:29:31.046]                     if (!future$lazy) 
[01:29:31.046]                       future <- run(future)
[01:29:31.046]                     invisible(future)
[01:29:31.046]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:31.046]                 }
[01:29:31.046]             }
[01:29:31.046]         }
[01:29:31.046]     })
[01:29:31.046]     if (TRUE) {
[01:29:31.046]         base::sink(type = "output", split = FALSE)
[01:29:31.046]         if (TRUE) {
[01:29:31.046]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:31.046]         }
[01:29:31.046]         else {
[01:29:31.046]             ...future.result["stdout"] <- base::list(NULL)
[01:29:31.046]         }
[01:29:31.046]         base::close(...future.stdout)
[01:29:31.046]         ...future.stdout <- NULL
[01:29:31.046]     }
[01:29:31.046]     ...future.result$conditions <- ...future.conditions
[01:29:31.046]     ...future.result$finished <- base::Sys.time()
[01:29:31.046]     ...future.result
[01:29:31.046] }
[01:29:31.051] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:31.051] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:31.052] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:31.052] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:31.053] MultisessionFuture started
[01:29:31.053] - Launch lazy future ... done
[01:29:31.053] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_4-777755'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96cf2b3a8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[01:29:31.070] receiveMessageFromWorker() for ClusterFuture ...
[01:29:31.070] - Validating connection of MultisessionFuture
[01:29:31.071] - received message: FutureResult
[01:29:31.071] - Received FutureResult
[01:29:31.071] - Erased future from FutureRegistry
[01:29:31.071] result() for ClusterFuture ...
[01:29:31.071] - result already collected: FutureResult
[01:29:31.072] result() for ClusterFuture ... done
[01:29:31.072] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.072] resolve() on list ...
[01:29:31.072]  recursive: 0
[01:29:31.073]  length: 4
[01:29:31.073] 
[01:29:31.073] Future #1
[01:29:31.073] result() for ClusterFuture ...
[01:29:31.073] - result already collected: FutureResult
[01:29:31.073] result() for ClusterFuture ... done
[01:29:31.074] result() for ClusterFuture ...
[01:29:31.074] - result already collected: FutureResult
[01:29:31.074] result() for ClusterFuture ... done
[01:29:31.074] signalConditionsASAP(MultisessionFuture, pos=1) ...
[01:29:31.074] - nx: 4
[01:29:31.074] - relay: TRUE
[01:29:31.075] - stdout: TRUE
[01:29:31.075] - signal: TRUE
[01:29:31.075] - resignal: FALSE
[01:29:31.075] - force: TRUE
[01:29:31.075] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:31.075] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:31.075]  - until=1
[01:29:31.076]  - relaying element #1
[01:29:31.076] result() for ClusterFuture ...
[01:29:31.076] - result already collected: FutureResult
[01:29:31.076] result() for ClusterFuture ... done
[01:29:31.076] result() for ClusterFuture ...
[01:29:31.076] - result already collected: FutureResult
[01:29:31.077] result() for ClusterFuture ... done
[01:29:31.077] result() for ClusterFuture ...
[01:29:31.077] - result already collected: FutureResult
[01:29:31.077] result() for ClusterFuture ... done
[01:29:31.077] result() for ClusterFuture ...
[01:29:31.077] - result already collected: FutureResult
[01:29:31.078] result() for ClusterFuture ... done
[01:29:31.078] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:31.078] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:31.078] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[01:29:31.078]  length: 3 (resolved future 1)
[01:29:31.079] Future #2
[01:29:31.079] result() for ClusterFuture ...
[01:29:31.079] - result already collected: FutureResult
[01:29:31.079] result() for ClusterFuture ... done
[01:29:31.079] result() for ClusterFuture ...
[01:29:31.079] - result already collected: FutureResult
[01:29:31.079] result() for ClusterFuture ... done
[01:29:31.080] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:29:31.080] - nx: 4
[01:29:31.080] - relay: TRUE
[01:29:31.080] - stdout: TRUE
[01:29:31.080] - signal: TRUE
[01:29:31.080] - resignal: FALSE
[01:29:31.081] - force: TRUE
[01:29:31.081] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:31.081] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:31.081]  - until=2
[01:29:31.081]  - relaying element #2
[01:29:31.081] result() for ClusterFuture ...
[01:29:31.082] - result already collected: FutureResult
[01:29:31.082] result() for ClusterFuture ... done
[01:29:31.082] result() for ClusterFuture ...
[01:29:31.082] - result already collected: FutureResult
[01:29:31.082] result() for ClusterFuture ... done
[01:29:31.082] result() for ClusterFuture ...
[01:29:31.083] - result already collected: FutureResult
[01:29:31.083] result() for ClusterFuture ... done
[01:29:31.083] result() for ClusterFuture ...
[01:29:31.083] - result already collected: FutureResult
[01:29:31.083] result() for ClusterFuture ... done
[01:29:31.083] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:31.084] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:31.084] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:29:31.084]  length: 2 (resolved future 2)
[01:29:31.084] Future #3
[01:29:31.084] result() for ClusterFuture ...
[01:29:31.084] - result already collected: FutureResult
[01:29:31.085] result() for ClusterFuture ... done
[01:29:31.085] result() for ClusterFuture ...
[01:29:31.085] - result already collected: FutureResult
[01:29:31.085] result() for ClusterFuture ... done
[01:29:31.085] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:29:31.085] - nx: 4
[01:29:31.086] - relay: TRUE
[01:29:31.086] - stdout: TRUE
[01:29:31.086] - signal: TRUE
[01:29:31.086] - resignal: FALSE
[01:29:31.086] - force: TRUE
[01:29:31.086] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:31.086] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:31.087]  - until=3
[01:29:31.087]  - relaying element #3
[01:29:31.087] result() for ClusterFuture ...
[01:29:31.087] - result already collected: FutureResult
[01:29:31.087] result() for ClusterFuture ... done
[01:29:31.088] result() for ClusterFuture ...
[01:29:31.088] - result already collected: FutureResult
[01:29:31.088] result() for ClusterFuture ... done
[01:29:31.088] result() for ClusterFuture ...
[01:29:31.088] - result already collected: FutureResult
[01:29:31.088] result() for ClusterFuture ... done
[01:29:31.089] result() for ClusterFuture ...
[01:29:31.089] - result already collected: FutureResult
[01:29:31.089] result() for ClusterFuture ... done
[01:29:31.089] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:31.089] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:31.089] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:29:31.090]  length: 1 (resolved future 3)
[01:29:31.090] Future #4
[01:29:31.090] result() for ClusterFuture ...
[01:29:31.090] - result already collected: FutureResult
[01:29:31.090] result() for ClusterFuture ... done
[01:29:31.091] result() for ClusterFuture ...
[01:29:31.091] - result already collected: FutureResult
[01:29:31.091] result() for ClusterFuture ... done
[01:29:31.091] signalConditionsASAP(MultisessionFuture, pos=4) ...
[01:29:31.091] - nx: 4
[01:29:31.091] - relay: TRUE
[01:29:31.092] - stdout: TRUE
[01:29:31.092] - signal: TRUE
[01:29:31.092] - resignal: FALSE
[01:29:31.092] - force: TRUE
[01:29:31.092] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:31.092] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:31.093]  - until=4
[01:29:31.093]  - relaying element #4
[01:29:31.093] result() for ClusterFuture ...
[01:29:31.093] - result already collected: FutureResult
[01:29:31.093] result() for ClusterFuture ... done
[01:29:31.093] result() for ClusterFuture ...
[01:29:31.094] - result already collected: FutureResult
[01:29:31.094] result() for ClusterFuture ... done
[01:29:31.094] result() for ClusterFuture ...
[01:29:31.094] - result already collected: FutureResult
[01:29:31.094] result() for ClusterFuture ... done
[01:29:31.094] result() for ClusterFuture ...
[01:29:31.095] - result already collected: FutureResult
[01:29:31.095] result() for ClusterFuture ... done
[01:29:31.095] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:31.095] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:31.095] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[01:29:31.095]  length: 0 (resolved future 4)
[01:29:31.096] Relaying remaining futures
[01:29:31.096] signalConditionsASAP(NULL, pos=0) ...
[01:29:31.096] - nx: 4
[01:29:31.096] - relay: TRUE
[01:29:31.096] - stdout: TRUE
[01:29:31.097] - signal: TRUE
[01:29:31.097] - resignal: FALSE
[01:29:31.097] - force: TRUE
[01:29:31.097] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:31.097] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[01:29:31.098] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:31.098] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:31.098] signalConditionsASAP(NULL, pos=0) ... done
[01:29:31.098] resolve() on list ... DONE
[01:29:31.098] result() for ClusterFuture ...
[01:29:31.098] - result already collected: FutureResult
[01:29:31.099] result() for ClusterFuture ... done
[01:29:31.099] result() for ClusterFuture ...
[01:29:31.099] - result already collected: FutureResult
[01:29:31.099] result() for ClusterFuture ... done
[01:29:31.099] result() for ClusterFuture ...
[01:29:31.099] - result already collected: FutureResult
[01:29:31.100] result() for ClusterFuture ... done
[01:29:31.100] result() for ClusterFuture ...
[01:29:31.100] - result already collected: FutureResult
[01:29:31.100] result() for ClusterFuture ... done
[01:29:31.100] result() for ClusterFuture ...
[01:29:31.100] - result already collected: FutureResult
[01:29:31.101] result() for ClusterFuture ... done
[01:29:31.101] result() for ClusterFuture ...
[01:29:31.101] - result already collected: FutureResult
[01:29:31.101] result() for ClusterFuture ... done
[01:29:31.101] result() for ClusterFuture ...
[01:29:31.101] - result already collected: FutureResult
[01:29:31.102] result() for ClusterFuture ... done
[01:29:31.102] result() for ClusterFuture ...
[01:29:31.102] - result already collected: FutureResult
[01:29:31.102] result() for ClusterFuture ... done
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 2

[[4]]
[1] 2

[01:29:31.102] getGlobalsAndPackages() ...
[01:29:31.103] Searching for globals...
[01:29:31.104] - globals found: [3] '{', 'sample', 'x'
[01:29:31.104] Searching for globals ... DONE
[01:29:31.104] Resolving globals: FALSE
[01:29:31.105] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:31.105] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:31.105] - globals: [1] 'x'
[01:29:31.106] 
[01:29:31.106] getGlobalsAndPackages() ... DONE
[01:29:31.106] run() for 'Future' ...
[01:29:31.106] - state: 'created'
[01:29:31.107] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:31.124] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.125] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:31.125]   - Field: 'node'
[01:29:31.125]   - Field: 'label'
[01:29:31.125]   - Field: 'local'
[01:29:31.126]   - Field: 'owner'
[01:29:31.126]   - Field: 'envir'
[01:29:31.126]   - Field: 'workers'
[01:29:31.126]   - Field: 'packages'
[01:29:31.126]   - Field: 'gc'
[01:29:31.127]   - Field: 'conditions'
[01:29:31.127]   - Field: 'persistent'
[01:29:31.127]   - Field: 'expr'
[01:29:31.127]   - Field: 'uuid'
[01:29:31.127]   - Field: 'seed'
[01:29:31.128]   - Field: 'version'
[01:29:31.128]   - Field: 'result'
[01:29:31.128]   - Field: 'asynchronous'
[01:29:31.128]   - Field: 'calls'
[01:29:31.128]   - Field: 'globals'
[01:29:31.128]   - Field: 'stdout'
[01:29:31.129]   - Field: 'earlySignal'
[01:29:31.129]   - Field: 'lazy'
[01:29:31.129]   - Field: 'state'
[01:29:31.129] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:31.129] - Launch lazy future ...
[01:29:31.130] Packages needed by the future expression (n = 0): <none>
[01:29:31.130] Packages needed by future strategies (n = 0): <none>
[01:29:31.130] {
[01:29:31.130]     {
[01:29:31.130]         {
[01:29:31.130]             ...future.startTime <- base::Sys.time()
[01:29:31.130]             {
[01:29:31.130]                 {
[01:29:31.130]                   {
[01:29:31.130]                     {
[01:29:31.130]                       base::local({
[01:29:31.130]                         has_future <- base::requireNamespace("future", 
[01:29:31.130]                           quietly = TRUE)
[01:29:31.130]                         if (has_future) {
[01:29:31.130]                           ns <- base::getNamespace("future")
[01:29:31.130]                           version <- ns[[".package"]][["version"]]
[01:29:31.130]                           if (is.null(version)) 
[01:29:31.130]                             version <- utils::packageVersion("future")
[01:29:31.130]                         }
[01:29:31.130]                         else {
[01:29:31.130]                           version <- NULL
[01:29:31.130]                         }
[01:29:31.130]                         if (!has_future || version < "1.8.0") {
[01:29:31.130]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:31.130]                             "", base::R.version$version.string), 
[01:29:31.130]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:31.130]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:31.130]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:31.130]                               "release", "version")], collapse = " "), 
[01:29:31.130]                             hostname = base::Sys.info()[["nodename"]])
[01:29:31.130]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:31.130]                             info)
[01:29:31.130]                           info <- base::paste(info, collapse = "; ")
[01:29:31.130]                           if (!has_future) {
[01:29:31.130]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:31.130]                               info)
[01:29:31.130]                           }
[01:29:31.130]                           else {
[01:29:31.130]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:31.130]                               info, version)
[01:29:31.130]                           }
[01:29:31.130]                           base::stop(msg)
[01:29:31.130]                         }
[01:29:31.130]                       })
[01:29:31.130]                     }
[01:29:31.130]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:31.130]                     base::options(mc.cores = 1L)
[01:29:31.130]                   }
[01:29:31.130]                   options(future.plan = NULL)
[01:29:31.130]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.130]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:31.130]                 }
[01:29:31.130]                 ...future.workdir <- getwd()
[01:29:31.130]             }
[01:29:31.130]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:31.130]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:31.130]         }
[01:29:31.130]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:31.130]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:31.130]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:31.130]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:31.130]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:31.130]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:31.130]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:31.130]             base::names(...future.oldOptions))
[01:29:31.130]     }
[01:29:31.130]     if (FALSE) {
[01:29:31.130]     }
[01:29:31.130]     else {
[01:29:31.130]         if (TRUE) {
[01:29:31.130]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:31.130]                 open = "w")
[01:29:31.130]         }
[01:29:31.130]         else {
[01:29:31.130]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:31.130]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:31.130]         }
[01:29:31.130]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:31.130]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:31.130]             base::sink(type = "output", split = FALSE)
[01:29:31.130]             base::close(...future.stdout)
[01:29:31.130]         }, add = TRUE)
[01:29:31.130]     }
[01:29:31.130]     ...future.frame <- base::sys.nframe()
[01:29:31.130]     ...future.conditions <- base::list()
[01:29:31.130]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:31.130]     if (FALSE) {
[01:29:31.130]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:31.130]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:31.130]     }
[01:29:31.130]     ...future.result <- base::tryCatch({
[01:29:31.130]         base::withCallingHandlers({
[01:29:31.130]             ...future.value <- base::withVisible(base::local({
[01:29:31.130]                 ...future.makeSendCondition <- base::local({
[01:29:31.130]                   sendCondition <- NULL
[01:29:31.130]                   function(frame = 1L) {
[01:29:31.130]                     if (is.function(sendCondition)) 
[01:29:31.130]                       return(sendCondition)
[01:29:31.130]                     ns <- getNamespace("parallel")
[01:29:31.130]                     if (exists("sendData", mode = "function", 
[01:29:31.130]                       envir = ns)) {
[01:29:31.130]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:31.130]                         envir = ns)
[01:29:31.130]                       envir <- sys.frame(frame)
[01:29:31.130]                       master <- NULL
[01:29:31.130]                       while (!identical(envir, .GlobalEnv) && 
[01:29:31.130]                         !identical(envir, emptyenv())) {
[01:29:31.130]                         if (exists("master", mode = "list", envir = envir, 
[01:29:31.130]                           inherits = FALSE)) {
[01:29:31.130]                           master <- get("master", mode = "list", 
[01:29:31.130]                             envir = envir, inherits = FALSE)
[01:29:31.130]                           if (inherits(master, c("SOCKnode", 
[01:29:31.130]                             "SOCK0node"))) {
[01:29:31.130]                             sendCondition <<- function(cond) {
[01:29:31.130]                               data <- list(type = "VALUE", value = cond, 
[01:29:31.130]                                 success = TRUE)
[01:29:31.130]                               parallel_sendData(master, data)
[01:29:31.130]                             }
[01:29:31.130]                             return(sendCondition)
[01:29:31.130]                           }
[01:29:31.130]                         }
[01:29:31.130]                         frame <- frame + 1L
[01:29:31.130]                         envir <- sys.frame(frame)
[01:29:31.130]                       }
[01:29:31.130]                     }
[01:29:31.130]                     sendCondition <<- function(cond) NULL
[01:29:31.130]                   }
[01:29:31.130]                 })
[01:29:31.130]                 withCallingHandlers({
[01:29:31.130]                   {
[01:29:31.130]                     sample(x, size = 1L)
[01:29:31.130]                   }
[01:29:31.130]                 }, immediateCondition = function(cond) {
[01:29:31.130]                   sendCondition <- ...future.makeSendCondition()
[01:29:31.130]                   sendCondition(cond)
[01:29:31.130]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.130]                   {
[01:29:31.130]                     inherits <- base::inherits
[01:29:31.130]                     invokeRestart <- base::invokeRestart
[01:29:31.130]                     is.null <- base::is.null
[01:29:31.130]                     muffled <- FALSE
[01:29:31.130]                     if (inherits(cond, "message")) {
[01:29:31.130]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:31.130]                       if (muffled) 
[01:29:31.130]                         invokeRestart("muffleMessage")
[01:29:31.130]                     }
[01:29:31.130]                     else if (inherits(cond, "warning")) {
[01:29:31.130]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:31.130]                       if (muffled) 
[01:29:31.130]                         invokeRestart("muffleWarning")
[01:29:31.130]                     }
[01:29:31.130]                     else if (inherits(cond, "condition")) {
[01:29:31.130]                       if (!is.null(pattern)) {
[01:29:31.130]                         computeRestarts <- base::computeRestarts
[01:29:31.130]                         grepl <- base::grepl
[01:29:31.130]                         restarts <- computeRestarts(cond)
[01:29:31.130]                         for (restart in restarts) {
[01:29:31.130]                           name <- restart$name
[01:29:31.130]                           if (is.null(name)) 
[01:29:31.130]                             next
[01:29:31.130]                           if (!grepl(pattern, name)) 
[01:29:31.130]                             next
[01:29:31.130]                           invokeRestart(restart)
[01:29:31.130]                           muffled <- TRUE
[01:29:31.130]                           break
[01:29:31.130]                         }
[01:29:31.130]                       }
[01:29:31.130]                     }
[01:29:31.130]                     invisible(muffled)
[01:29:31.130]                   }
[01:29:31.130]                   muffleCondition(cond)
[01:29:31.130]                 })
[01:29:31.130]             }))
[01:29:31.130]             future::FutureResult(value = ...future.value$value, 
[01:29:31.130]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.130]                   ...future.rng), globalenv = if (FALSE) 
[01:29:31.130]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:31.130]                     ...future.globalenv.names))
[01:29:31.130]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:31.130]         }, condition = base::local({
[01:29:31.130]             c <- base::c
[01:29:31.130]             inherits <- base::inherits
[01:29:31.130]             invokeRestart <- base::invokeRestart
[01:29:31.130]             length <- base::length
[01:29:31.130]             list <- base::list
[01:29:31.130]             seq.int <- base::seq.int
[01:29:31.130]             signalCondition <- base::signalCondition
[01:29:31.130]             sys.calls <- base::sys.calls
[01:29:31.130]             `[[` <- base::`[[`
[01:29:31.130]             `+` <- base::`+`
[01:29:31.130]             `<<-` <- base::`<<-`
[01:29:31.130]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:31.130]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:31.130]                   3L)]
[01:29:31.130]             }
[01:29:31.130]             function(cond) {
[01:29:31.130]                 is_error <- inherits(cond, "error")
[01:29:31.130]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:31.130]                   NULL)
[01:29:31.130]                 if (is_error) {
[01:29:31.130]                   sessionInformation <- function() {
[01:29:31.130]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:31.130]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:31.130]                       search = base::search(), system = base::Sys.info())
[01:29:31.130]                   }
[01:29:31.130]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.130]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:31.130]                     cond$call), session = sessionInformation(), 
[01:29:31.130]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:31.130]                   signalCondition(cond)
[01:29:31.130]                 }
[01:29:31.130]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:31.130]                 "immediateCondition"))) {
[01:29:31.130]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:31.130]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.130]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:31.130]                   if (TRUE && !signal) {
[01:29:31.130]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.130]                     {
[01:29:31.130]                       inherits <- base::inherits
[01:29:31.130]                       invokeRestart <- base::invokeRestart
[01:29:31.130]                       is.null <- base::is.null
[01:29:31.130]                       muffled <- FALSE
[01:29:31.130]                       if (inherits(cond, "message")) {
[01:29:31.130]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.130]                         if (muffled) 
[01:29:31.130]                           invokeRestart("muffleMessage")
[01:29:31.130]                       }
[01:29:31.130]                       else if (inherits(cond, "warning")) {
[01:29:31.130]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.130]                         if (muffled) 
[01:29:31.130]                           invokeRestart("muffleWarning")
[01:29:31.130]                       }
[01:29:31.130]                       else if (inherits(cond, "condition")) {
[01:29:31.130]                         if (!is.null(pattern)) {
[01:29:31.130]                           computeRestarts <- base::computeRestarts
[01:29:31.130]                           grepl <- base::grepl
[01:29:31.130]                           restarts <- computeRestarts(cond)
[01:29:31.130]                           for (restart in restarts) {
[01:29:31.130]                             name <- restart$name
[01:29:31.130]                             if (is.null(name)) 
[01:29:31.130]                               next
[01:29:31.130]                             if (!grepl(pattern, name)) 
[01:29:31.130]                               next
[01:29:31.130]                             invokeRestart(restart)
[01:29:31.130]                             muffled <- TRUE
[01:29:31.130]                             break
[01:29:31.130]                           }
[01:29:31.130]                         }
[01:29:31.130]                       }
[01:29:31.130]                       invisible(muffled)
[01:29:31.130]                     }
[01:29:31.130]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.130]                   }
[01:29:31.130]                 }
[01:29:31.130]                 else {
[01:29:31.130]                   if (TRUE) {
[01:29:31.130]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.130]                     {
[01:29:31.130]                       inherits <- base::inherits
[01:29:31.130]                       invokeRestart <- base::invokeRestart
[01:29:31.130]                       is.null <- base::is.null
[01:29:31.130]                       muffled <- FALSE
[01:29:31.130]                       if (inherits(cond, "message")) {
[01:29:31.130]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.130]                         if (muffled) 
[01:29:31.130]                           invokeRestart("muffleMessage")
[01:29:31.130]                       }
[01:29:31.130]                       else if (inherits(cond, "warning")) {
[01:29:31.130]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.130]                         if (muffled) 
[01:29:31.130]                           invokeRestart("muffleWarning")
[01:29:31.130]                       }
[01:29:31.130]                       else if (inherits(cond, "condition")) {
[01:29:31.130]                         if (!is.null(pattern)) {
[01:29:31.130]                           computeRestarts <- base::computeRestarts
[01:29:31.130]                           grepl <- base::grepl
[01:29:31.130]                           restarts <- computeRestarts(cond)
[01:29:31.130]                           for (restart in restarts) {
[01:29:31.130]                             name <- restart$name
[01:29:31.130]                             if (is.null(name)) 
[01:29:31.130]                               next
[01:29:31.130]                             if (!grepl(pattern, name)) 
[01:29:31.130]                               next
[01:29:31.130]                             invokeRestart(restart)
[01:29:31.130]                             muffled <- TRUE
[01:29:31.130]                             break
[01:29:31.130]                           }
[01:29:31.130]                         }
[01:29:31.130]                       }
[01:29:31.130]                       invisible(muffled)
[01:29:31.130]                     }
[01:29:31.130]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.130]                   }
[01:29:31.130]                 }
[01:29:31.130]             }
[01:29:31.130]         }))
[01:29:31.130]     }, error = function(ex) {
[01:29:31.130]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:31.130]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.130]                 ...future.rng), started = ...future.startTime, 
[01:29:31.130]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:31.130]             version = "1.8"), class = "FutureResult")
[01:29:31.130]     }, finally = {
[01:29:31.130]         if (!identical(...future.workdir, getwd())) 
[01:29:31.130]             setwd(...future.workdir)
[01:29:31.130]         {
[01:29:31.130]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:31.130]                 ...future.oldOptions$nwarnings <- NULL
[01:29:31.130]             }
[01:29:31.130]             base::options(...future.oldOptions)
[01:29:31.130]             if (.Platform$OS.type == "windows") {
[01:29:31.130]                 old_names <- names(...future.oldEnvVars)
[01:29:31.130]                 envs <- base::Sys.getenv()
[01:29:31.130]                 names <- names(envs)
[01:29:31.130]                 common <- intersect(names, old_names)
[01:29:31.130]                 added <- setdiff(names, old_names)
[01:29:31.130]                 removed <- setdiff(old_names, names)
[01:29:31.130]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:31.130]                   envs[common]]
[01:29:31.130]                 NAMES <- toupper(changed)
[01:29:31.130]                 args <- list()
[01:29:31.130]                 for (kk in seq_along(NAMES)) {
[01:29:31.130]                   name <- changed[[kk]]
[01:29:31.130]                   NAME <- NAMES[[kk]]
[01:29:31.130]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.130]                     next
[01:29:31.130]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.130]                 }
[01:29:31.130]                 NAMES <- toupper(added)
[01:29:31.130]                 for (kk in seq_along(NAMES)) {
[01:29:31.130]                   name <- added[[kk]]
[01:29:31.130]                   NAME <- NAMES[[kk]]
[01:29:31.130]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.130]                     next
[01:29:31.130]                   args[[name]] <- ""
[01:29:31.130]                 }
[01:29:31.130]                 NAMES <- toupper(removed)
[01:29:31.130]                 for (kk in seq_along(NAMES)) {
[01:29:31.130]                   name <- removed[[kk]]
[01:29:31.130]                   NAME <- NAMES[[kk]]
[01:29:31.130]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.130]                     next
[01:29:31.130]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.130]                 }
[01:29:31.130]                 if (length(args) > 0) 
[01:29:31.130]                   base::do.call(base::Sys.setenv, args = args)
[01:29:31.130]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:31.130]             }
[01:29:31.130]             else {
[01:29:31.130]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:31.130]             }
[01:29:31.130]             {
[01:29:31.130]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:31.130]                   0L) {
[01:29:31.130]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:31.130]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:31.130]                   base::options(opts)
[01:29:31.130]                 }
[01:29:31.130]                 {
[01:29:31.130]                   {
[01:29:31.130]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:31.130]                     NULL
[01:29:31.130]                   }
[01:29:31.130]                   options(future.plan = NULL)
[01:29:31.130]                   if (is.na(NA_character_)) 
[01:29:31.130]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.130]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:31.130]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:31.130]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:31.130]                     envir = parent.frame()) 
[01:29:31.130]                   {
[01:29:31.130]                     if (is.function(workers)) 
[01:29:31.130]                       workers <- workers()
[01:29:31.130]                     workers <- structure(as.integer(workers), 
[01:29:31.130]                       class = class(workers))
[01:29:31.130]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:31.130]                       workers >= 1)
[01:29:31.130]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:31.130]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:31.130]                     }
[01:29:31.130]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:31.130]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:31.130]                       envir = envir)
[01:29:31.130]                     if (!future$lazy) 
[01:29:31.130]                       future <- run(future)
[01:29:31.130]                     invisible(future)
[01:29:31.130]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:31.130]                 }
[01:29:31.130]             }
[01:29:31.130]         }
[01:29:31.130]     })
[01:29:31.130]     if (TRUE) {
[01:29:31.130]         base::sink(type = "output", split = FALSE)
[01:29:31.130]         if (TRUE) {
[01:29:31.130]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:31.130]         }
[01:29:31.130]         else {
[01:29:31.130]             ...future.result["stdout"] <- base::list(NULL)
[01:29:31.130]         }
[01:29:31.130]         base::close(...future.stdout)
[01:29:31.130]         ...future.stdout <- NULL
[01:29:31.130]     }
[01:29:31.130]     ...future.result$conditions <- ...future.conditions
[01:29:31.130]     ...future.result$finished <- base::Sys.time()
[01:29:31.130]     ...future.result
[01:29:31.130] }
[01:29:31.136] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:31.136] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:31.136] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:31.137] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:31.137] MultisessionFuture started
[01:29:31.138] - Launch lazy future ... done
[01:29:31.138] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_1-249481'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b970322ab0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[01:29:31.155] receiveMessageFromWorker() for ClusterFuture ...
[01:29:31.155] - Validating connection of MultisessionFuture
[01:29:31.156] - received message: FutureResult
[01:29:31.156] - Received FutureResult
[01:29:31.156] - Erased future from FutureRegistry
[01:29:31.156] result() for ClusterFuture ...
[01:29:31.156] - result already collected: FutureResult
[01:29:31.156] result() for ClusterFuture ... done
[01:29:31.157] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.157] getGlobalsAndPackages() ...
[01:29:31.157] Searching for globals...
[01:29:31.158] - globals found: [3] '{', 'sample', 'x'
[01:29:31.159] Searching for globals ... DONE
[01:29:31.159] Resolving globals: FALSE
[01:29:31.161] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:31.161] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:31.162] - globals: [1] 'x'
[01:29:31.162] 
[01:29:31.162] getGlobalsAndPackages() ... DONE
[01:29:31.163] run() for 'Future' ...
[01:29:31.163] - state: 'created'
[01:29:31.163] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:31.181] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.181] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:31.182]   - Field: 'node'
[01:29:31.182]   - Field: 'label'
[01:29:31.182]   - Field: 'local'
[01:29:31.183]   - Field: 'owner'
[01:29:31.183]   - Field: 'envir'
[01:29:31.183]   - Field: 'workers'
[01:29:31.183]   - Field: 'packages'
[01:29:31.184]   - Field: 'gc'
[01:29:31.184]   - Field: 'conditions'
[01:29:31.184]   - Field: 'persistent'
[01:29:31.184]   - Field: 'expr'
[01:29:31.185]   - Field: 'uuid'
[01:29:31.185]   - Field: 'seed'
[01:29:31.185]   - Field: 'version'
[01:29:31.185]   - Field: 'result'
[01:29:31.186]   - Field: 'asynchronous'
[01:29:31.186]   - Field: 'calls'
[01:29:31.186]   - Field: 'globals'
[01:29:31.187]   - Field: 'stdout'
[01:29:31.187]   - Field: 'earlySignal'
[01:29:31.187]   - Field: 'lazy'
[01:29:31.187]   - Field: 'state'
[01:29:31.188] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:31.188] - Launch lazy future ...
[01:29:31.189] Packages needed by the future expression (n = 0): <none>
[01:29:31.189] Packages needed by future strategies (n = 0): <none>
[01:29:31.190] {
[01:29:31.190]     {
[01:29:31.190]         {
[01:29:31.190]             ...future.startTime <- base::Sys.time()
[01:29:31.190]             {
[01:29:31.190]                 {
[01:29:31.190]                   {
[01:29:31.190]                     {
[01:29:31.190]                       base::local({
[01:29:31.190]                         has_future <- base::requireNamespace("future", 
[01:29:31.190]                           quietly = TRUE)
[01:29:31.190]                         if (has_future) {
[01:29:31.190]                           ns <- base::getNamespace("future")
[01:29:31.190]                           version <- ns[[".package"]][["version"]]
[01:29:31.190]                           if (is.null(version)) 
[01:29:31.190]                             version <- utils::packageVersion("future")
[01:29:31.190]                         }
[01:29:31.190]                         else {
[01:29:31.190]                           version <- NULL
[01:29:31.190]                         }
[01:29:31.190]                         if (!has_future || version < "1.8.0") {
[01:29:31.190]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:31.190]                             "", base::R.version$version.string), 
[01:29:31.190]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:31.190]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:31.190]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:31.190]                               "release", "version")], collapse = " "), 
[01:29:31.190]                             hostname = base::Sys.info()[["nodename"]])
[01:29:31.190]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:31.190]                             info)
[01:29:31.190]                           info <- base::paste(info, collapse = "; ")
[01:29:31.190]                           if (!has_future) {
[01:29:31.190]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:31.190]                               info)
[01:29:31.190]                           }
[01:29:31.190]                           else {
[01:29:31.190]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:31.190]                               info, version)
[01:29:31.190]                           }
[01:29:31.190]                           base::stop(msg)
[01:29:31.190]                         }
[01:29:31.190]                       })
[01:29:31.190]                     }
[01:29:31.190]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:31.190]                     base::options(mc.cores = 1L)
[01:29:31.190]                   }
[01:29:31.190]                   options(future.plan = NULL)
[01:29:31.190]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.190]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:31.190]                 }
[01:29:31.190]                 ...future.workdir <- getwd()
[01:29:31.190]             }
[01:29:31.190]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:31.190]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:31.190]         }
[01:29:31.190]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:31.190]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:31.190]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:31.190]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:31.190]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:31.190]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:31.190]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:31.190]             base::names(...future.oldOptions))
[01:29:31.190]     }
[01:29:31.190]     if (FALSE) {
[01:29:31.190]     }
[01:29:31.190]     else {
[01:29:31.190]         if (TRUE) {
[01:29:31.190]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:31.190]                 open = "w")
[01:29:31.190]         }
[01:29:31.190]         else {
[01:29:31.190]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:31.190]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:31.190]         }
[01:29:31.190]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:31.190]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:31.190]             base::sink(type = "output", split = FALSE)
[01:29:31.190]             base::close(...future.stdout)
[01:29:31.190]         }, add = TRUE)
[01:29:31.190]     }
[01:29:31.190]     ...future.frame <- base::sys.nframe()
[01:29:31.190]     ...future.conditions <- base::list()
[01:29:31.190]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:31.190]     if (FALSE) {
[01:29:31.190]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:31.190]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:31.190]     }
[01:29:31.190]     ...future.result <- base::tryCatch({
[01:29:31.190]         base::withCallingHandlers({
[01:29:31.190]             ...future.value <- base::withVisible(base::local({
[01:29:31.190]                 ...future.makeSendCondition <- base::local({
[01:29:31.190]                   sendCondition <- NULL
[01:29:31.190]                   function(frame = 1L) {
[01:29:31.190]                     if (is.function(sendCondition)) 
[01:29:31.190]                       return(sendCondition)
[01:29:31.190]                     ns <- getNamespace("parallel")
[01:29:31.190]                     if (exists("sendData", mode = "function", 
[01:29:31.190]                       envir = ns)) {
[01:29:31.190]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:31.190]                         envir = ns)
[01:29:31.190]                       envir <- sys.frame(frame)
[01:29:31.190]                       master <- NULL
[01:29:31.190]                       while (!identical(envir, .GlobalEnv) && 
[01:29:31.190]                         !identical(envir, emptyenv())) {
[01:29:31.190]                         if (exists("master", mode = "list", envir = envir, 
[01:29:31.190]                           inherits = FALSE)) {
[01:29:31.190]                           master <- get("master", mode = "list", 
[01:29:31.190]                             envir = envir, inherits = FALSE)
[01:29:31.190]                           if (inherits(master, c("SOCKnode", 
[01:29:31.190]                             "SOCK0node"))) {
[01:29:31.190]                             sendCondition <<- function(cond) {
[01:29:31.190]                               data <- list(type = "VALUE", value = cond, 
[01:29:31.190]                                 success = TRUE)
[01:29:31.190]                               parallel_sendData(master, data)
[01:29:31.190]                             }
[01:29:31.190]                             return(sendCondition)
[01:29:31.190]                           }
[01:29:31.190]                         }
[01:29:31.190]                         frame <- frame + 1L
[01:29:31.190]                         envir <- sys.frame(frame)
[01:29:31.190]                       }
[01:29:31.190]                     }
[01:29:31.190]                     sendCondition <<- function(cond) NULL
[01:29:31.190]                   }
[01:29:31.190]                 })
[01:29:31.190]                 withCallingHandlers({
[01:29:31.190]                   {
[01:29:31.190]                     sample(x, size = 1L)
[01:29:31.190]                   }
[01:29:31.190]                 }, immediateCondition = function(cond) {
[01:29:31.190]                   sendCondition <- ...future.makeSendCondition()
[01:29:31.190]                   sendCondition(cond)
[01:29:31.190]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.190]                   {
[01:29:31.190]                     inherits <- base::inherits
[01:29:31.190]                     invokeRestart <- base::invokeRestart
[01:29:31.190]                     is.null <- base::is.null
[01:29:31.190]                     muffled <- FALSE
[01:29:31.190]                     if (inherits(cond, "message")) {
[01:29:31.190]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:31.190]                       if (muffled) 
[01:29:31.190]                         invokeRestart("muffleMessage")
[01:29:31.190]                     }
[01:29:31.190]                     else if (inherits(cond, "warning")) {
[01:29:31.190]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:31.190]                       if (muffled) 
[01:29:31.190]                         invokeRestart("muffleWarning")
[01:29:31.190]                     }
[01:29:31.190]                     else if (inherits(cond, "condition")) {
[01:29:31.190]                       if (!is.null(pattern)) {
[01:29:31.190]                         computeRestarts <- base::computeRestarts
[01:29:31.190]                         grepl <- base::grepl
[01:29:31.190]                         restarts <- computeRestarts(cond)
[01:29:31.190]                         for (restart in restarts) {
[01:29:31.190]                           name <- restart$name
[01:29:31.190]                           if (is.null(name)) 
[01:29:31.190]                             next
[01:29:31.190]                           if (!grepl(pattern, name)) 
[01:29:31.190]                             next
[01:29:31.190]                           invokeRestart(restart)
[01:29:31.190]                           muffled <- TRUE
[01:29:31.190]                           break
[01:29:31.190]                         }
[01:29:31.190]                       }
[01:29:31.190]                     }
[01:29:31.190]                     invisible(muffled)
[01:29:31.190]                   }
[01:29:31.190]                   muffleCondition(cond)
[01:29:31.190]                 })
[01:29:31.190]             }))
[01:29:31.190]             future::FutureResult(value = ...future.value$value, 
[01:29:31.190]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.190]                   ...future.rng), globalenv = if (FALSE) 
[01:29:31.190]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:31.190]                     ...future.globalenv.names))
[01:29:31.190]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:31.190]         }, condition = base::local({
[01:29:31.190]             c <- base::c
[01:29:31.190]             inherits <- base::inherits
[01:29:31.190]             invokeRestart <- base::invokeRestart
[01:29:31.190]             length <- base::length
[01:29:31.190]             list <- base::list
[01:29:31.190]             seq.int <- base::seq.int
[01:29:31.190]             signalCondition <- base::signalCondition
[01:29:31.190]             sys.calls <- base::sys.calls
[01:29:31.190]             `[[` <- base::`[[`
[01:29:31.190]             `+` <- base::`+`
[01:29:31.190]             `<<-` <- base::`<<-`
[01:29:31.190]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:31.190]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:31.190]                   3L)]
[01:29:31.190]             }
[01:29:31.190]             function(cond) {
[01:29:31.190]                 is_error <- inherits(cond, "error")
[01:29:31.190]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:31.190]                   NULL)
[01:29:31.190]                 if (is_error) {
[01:29:31.190]                   sessionInformation <- function() {
[01:29:31.190]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:31.190]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:31.190]                       search = base::search(), system = base::Sys.info())
[01:29:31.190]                   }
[01:29:31.190]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.190]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:31.190]                     cond$call), session = sessionInformation(), 
[01:29:31.190]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:31.190]                   signalCondition(cond)
[01:29:31.190]                 }
[01:29:31.190]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:31.190]                 "immediateCondition"))) {
[01:29:31.190]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:31.190]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.190]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:31.190]                   if (TRUE && !signal) {
[01:29:31.190]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.190]                     {
[01:29:31.190]                       inherits <- base::inherits
[01:29:31.190]                       invokeRestart <- base::invokeRestart
[01:29:31.190]                       is.null <- base::is.null
[01:29:31.190]                       muffled <- FALSE
[01:29:31.190]                       if (inherits(cond, "message")) {
[01:29:31.190]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.190]                         if (muffled) 
[01:29:31.190]                           invokeRestart("muffleMessage")
[01:29:31.190]                       }
[01:29:31.190]                       else if (inherits(cond, "warning")) {
[01:29:31.190]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.190]                         if (muffled) 
[01:29:31.190]                           invokeRestart("muffleWarning")
[01:29:31.190]                       }
[01:29:31.190]                       else if (inherits(cond, "condition")) {
[01:29:31.190]                         if (!is.null(pattern)) {
[01:29:31.190]                           computeRestarts <- base::computeRestarts
[01:29:31.190]                           grepl <- base::grepl
[01:29:31.190]                           restarts <- computeRestarts(cond)
[01:29:31.190]                           for (restart in restarts) {
[01:29:31.190]                             name <- restart$name
[01:29:31.190]                             if (is.null(name)) 
[01:29:31.190]                               next
[01:29:31.190]                             if (!grepl(pattern, name)) 
[01:29:31.190]                               next
[01:29:31.190]                             invokeRestart(restart)
[01:29:31.190]                             muffled <- TRUE
[01:29:31.190]                             break
[01:29:31.190]                           }
[01:29:31.190]                         }
[01:29:31.190]                       }
[01:29:31.190]                       invisible(muffled)
[01:29:31.190]                     }
[01:29:31.190]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.190]                   }
[01:29:31.190]                 }
[01:29:31.190]                 else {
[01:29:31.190]                   if (TRUE) {
[01:29:31.190]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.190]                     {
[01:29:31.190]                       inherits <- base::inherits
[01:29:31.190]                       invokeRestart <- base::invokeRestart
[01:29:31.190]                       is.null <- base::is.null
[01:29:31.190]                       muffled <- FALSE
[01:29:31.190]                       if (inherits(cond, "message")) {
[01:29:31.190]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.190]                         if (muffled) 
[01:29:31.190]                           invokeRestart("muffleMessage")
[01:29:31.190]                       }
[01:29:31.190]                       else if (inherits(cond, "warning")) {
[01:29:31.190]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.190]                         if (muffled) 
[01:29:31.190]                           invokeRestart("muffleWarning")
[01:29:31.190]                       }
[01:29:31.190]                       else if (inherits(cond, "condition")) {
[01:29:31.190]                         if (!is.null(pattern)) {
[01:29:31.190]                           computeRestarts <- base::computeRestarts
[01:29:31.190]                           grepl <- base::grepl
[01:29:31.190]                           restarts <- computeRestarts(cond)
[01:29:31.190]                           for (restart in restarts) {
[01:29:31.190]                             name <- restart$name
[01:29:31.190]                             if (is.null(name)) 
[01:29:31.190]                               next
[01:29:31.190]                             if (!grepl(pattern, name)) 
[01:29:31.190]                               next
[01:29:31.190]                             invokeRestart(restart)
[01:29:31.190]                             muffled <- TRUE
[01:29:31.190]                             break
[01:29:31.190]                           }
[01:29:31.190]                         }
[01:29:31.190]                       }
[01:29:31.190]                       invisible(muffled)
[01:29:31.190]                     }
[01:29:31.190]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.190]                   }
[01:29:31.190]                 }
[01:29:31.190]             }
[01:29:31.190]         }))
[01:29:31.190]     }, error = function(ex) {
[01:29:31.190]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:31.190]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.190]                 ...future.rng), started = ...future.startTime, 
[01:29:31.190]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:31.190]             version = "1.8"), class = "FutureResult")
[01:29:31.190]     }, finally = {
[01:29:31.190]         if (!identical(...future.workdir, getwd())) 
[01:29:31.190]             setwd(...future.workdir)
[01:29:31.190]         {
[01:29:31.190]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:31.190]                 ...future.oldOptions$nwarnings <- NULL
[01:29:31.190]             }
[01:29:31.190]             base::options(...future.oldOptions)
[01:29:31.190]             if (.Platform$OS.type == "windows") {
[01:29:31.190]                 old_names <- names(...future.oldEnvVars)
[01:29:31.190]                 envs <- base::Sys.getenv()
[01:29:31.190]                 names <- names(envs)
[01:29:31.190]                 common <- intersect(names, old_names)
[01:29:31.190]                 added <- setdiff(names, old_names)
[01:29:31.190]                 removed <- setdiff(old_names, names)
[01:29:31.190]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:31.190]                   envs[common]]
[01:29:31.190]                 NAMES <- toupper(changed)
[01:29:31.190]                 args <- list()
[01:29:31.190]                 for (kk in seq_along(NAMES)) {
[01:29:31.190]                   name <- changed[[kk]]
[01:29:31.190]                   NAME <- NAMES[[kk]]
[01:29:31.190]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.190]                     next
[01:29:31.190]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.190]                 }
[01:29:31.190]                 NAMES <- toupper(added)
[01:29:31.190]                 for (kk in seq_along(NAMES)) {
[01:29:31.190]                   name <- added[[kk]]
[01:29:31.190]                   NAME <- NAMES[[kk]]
[01:29:31.190]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.190]                     next
[01:29:31.190]                   args[[name]] <- ""
[01:29:31.190]                 }
[01:29:31.190]                 NAMES <- toupper(removed)
[01:29:31.190]                 for (kk in seq_along(NAMES)) {
[01:29:31.190]                   name <- removed[[kk]]
[01:29:31.190]                   NAME <- NAMES[[kk]]
[01:29:31.190]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.190]                     next
[01:29:31.190]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.190]                 }
[01:29:31.190]                 if (length(args) > 0) 
[01:29:31.190]                   base::do.call(base::Sys.setenv, args = args)
[01:29:31.190]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:31.190]             }
[01:29:31.190]             else {
[01:29:31.190]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:31.190]             }
[01:29:31.190]             {
[01:29:31.190]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:31.190]                   0L) {
[01:29:31.190]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:31.190]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:31.190]                   base::options(opts)
[01:29:31.190]                 }
[01:29:31.190]                 {
[01:29:31.190]                   {
[01:29:31.190]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:31.190]                     NULL
[01:29:31.190]                   }
[01:29:31.190]                   options(future.plan = NULL)
[01:29:31.190]                   if (is.na(NA_character_)) 
[01:29:31.190]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.190]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:31.190]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:31.190]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:31.190]                     envir = parent.frame()) 
[01:29:31.190]                   {
[01:29:31.190]                     if (is.function(workers)) 
[01:29:31.190]                       workers <- workers()
[01:29:31.190]                     workers <- structure(as.integer(workers), 
[01:29:31.190]                       class = class(workers))
[01:29:31.190]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:31.190]                       workers >= 1)
[01:29:31.190]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:31.190]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:31.190]                     }
[01:29:31.190]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:31.190]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:31.190]                       envir = envir)
[01:29:31.190]                     if (!future$lazy) 
[01:29:31.190]                       future <- run(future)
[01:29:31.190]                     invisible(future)
[01:29:31.190]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:31.190]                 }
[01:29:31.190]             }
[01:29:31.190]         }
[01:29:31.190]     })
[01:29:31.190]     if (TRUE) {
[01:29:31.190]         base::sink(type = "output", split = FALSE)
[01:29:31.190]         if (TRUE) {
[01:29:31.190]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:31.190]         }
[01:29:31.190]         else {
[01:29:31.190]             ...future.result["stdout"] <- base::list(NULL)
[01:29:31.190]         }
[01:29:31.190]         base::close(...future.stdout)
[01:29:31.190]         ...future.stdout <- NULL
[01:29:31.190]     }
[01:29:31.190]     ...future.result$conditions <- ...future.conditions
[01:29:31.190]     ...future.result$finished <- base::Sys.time()
[01:29:31.190]     ...future.result
[01:29:31.190] }
[01:29:31.197] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:31.197] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:31.198] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:31.198] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:31.199] MultisessionFuture started
[01:29:31.199] - Launch lazy future ... done
[01:29:31.200] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_2-778592'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b970322ab0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[01:29:31.218] receiveMessageFromWorker() for ClusterFuture ...
[01:29:31.219] - Validating connection of MultisessionFuture
[01:29:31.219] - received message: FutureResult
[01:29:31.219] - Received FutureResult
[01:29:31.220] - Erased future from FutureRegistry
[01:29:31.220] result() for ClusterFuture ...
[01:29:31.220] - result already collected: FutureResult
[01:29:31.220] result() for ClusterFuture ... done
[01:29:31.220] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.221] getGlobalsAndPackages() ...
[01:29:31.221] Searching for globals...
[01:29:31.223] - globals found: [3] '{', 'sample', 'x'
[01:29:31.223] Searching for globals ... DONE
[01:29:31.223] Resolving globals: FALSE
[01:29:31.224] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:31.224] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:31.225] - globals: [1] 'x'
[01:29:31.225] 
[01:29:31.225] getGlobalsAndPackages() ... DONE
[01:29:31.225] run() for 'Future' ...
[01:29:31.226] - state: 'created'
[01:29:31.226] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:31.243] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.243] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:31.243]   - Field: 'node'
[01:29:31.243]   - Field: 'label'
[01:29:31.244]   - Field: 'local'
[01:29:31.244]   - Field: 'owner'
[01:29:31.244]   - Field: 'envir'
[01:29:31.244]   - Field: 'workers'
[01:29:31.245]   - Field: 'packages'
[01:29:31.245]   - Field: 'gc'
[01:29:31.245]   - Field: 'conditions'
[01:29:31.245]   - Field: 'persistent'
[01:29:31.245]   - Field: 'expr'
[01:29:31.246]   - Field: 'uuid'
[01:29:31.246]   - Field: 'seed'
[01:29:31.246]   - Field: 'version'
[01:29:31.246]   - Field: 'result'
[01:29:31.246]   - Field: 'asynchronous'
[01:29:31.247]   - Field: 'calls'
[01:29:31.247]   - Field: 'globals'
[01:29:31.247]   - Field: 'stdout'
[01:29:31.247]   - Field: 'earlySignal'
[01:29:31.248]   - Field: 'lazy'
[01:29:31.248]   - Field: 'state'
[01:29:31.248] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:31.248] - Launch lazy future ...
[01:29:31.249] Packages needed by the future expression (n = 0): <none>
[01:29:31.249] Packages needed by future strategies (n = 0): <none>
[01:29:31.250] {
[01:29:31.250]     {
[01:29:31.250]         {
[01:29:31.250]             ...future.startTime <- base::Sys.time()
[01:29:31.250]             {
[01:29:31.250]                 {
[01:29:31.250]                   {
[01:29:31.250]                     {
[01:29:31.250]                       base::local({
[01:29:31.250]                         has_future <- base::requireNamespace("future", 
[01:29:31.250]                           quietly = TRUE)
[01:29:31.250]                         if (has_future) {
[01:29:31.250]                           ns <- base::getNamespace("future")
[01:29:31.250]                           version <- ns[[".package"]][["version"]]
[01:29:31.250]                           if (is.null(version)) 
[01:29:31.250]                             version <- utils::packageVersion("future")
[01:29:31.250]                         }
[01:29:31.250]                         else {
[01:29:31.250]                           version <- NULL
[01:29:31.250]                         }
[01:29:31.250]                         if (!has_future || version < "1.8.0") {
[01:29:31.250]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:31.250]                             "", base::R.version$version.string), 
[01:29:31.250]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:31.250]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:31.250]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:31.250]                               "release", "version")], collapse = " "), 
[01:29:31.250]                             hostname = base::Sys.info()[["nodename"]])
[01:29:31.250]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:31.250]                             info)
[01:29:31.250]                           info <- base::paste(info, collapse = "; ")
[01:29:31.250]                           if (!has_future) {
[01:29:31.250]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:31.250]                               info)
[01:29:31.250]                           }
[01:29:31.250]                           else {
[01:29:31.250]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:31.250]                               info, version)
[01:29:31.250]                           }
[01:29:31.250]                           base::stop(msg)
[01:29:31.250]                         }
[01:29:31.250]                       })
[01:29:31.250]                     }
[01:29:31.250]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:31.250]                     base::options(mc.cores = 1L)
[01:29:31.250]                   }
[01:29:31.250]                   options(future.plan = NULL)
[01:29:31.250]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.250]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:31.250]                 }
[01:29:31.250]                 ...future.workdir <- getwd()
[01:29:31.250]             }
[01:29:31.250]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:31.250]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:31.250]         }
[01:29:31.250]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:31.250]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:31.250]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:31.250]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:31.250]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:31.250]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:31.250]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:31.250]             base::names(...future.oldOptions))
[01:29:31.250]     }
[01:29:31.250]     if (FALSE) {
[01:29:31.250]     }
[01:29:31.250]     else {
[01:29:31.250]         if (TRUE) {
[01:29:31.250]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:31.250]                 open = "w")
[01:29:31.250]         }
[01:29:31.250]         else {
[01:29:31.250]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:31.250]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:31.250]         }
[01:29:31.250]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:31.250]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:31.250]             base::sink(type = "output", split = FALSE)
[01:29:31.250]             base::close(...future.stdout)
[01:29:31.250]         }, add = TRUE)
[01:29:31.250]     }
[01:29:31.250]     ...future.frame <- base::sys.nframe()
[01:29:31.250]     ...future.conditions <- base::list()
[01:29:31.250]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:31.250]     if (FALSE) {
[01:29:31.250]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:31.250]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:31.250]     }
[01:29:31.250]     ...future.result <- base::tryCatch({
[01:29:31.250]         base::withCallingHandlers({
[01:29:31.250]             ...future.value <- base::withVisible(base::local({
[01:29:31.250]                 ...future.makeSendCondition <- base::local({
[01:29:31.250]                   sendCondition <- NULL
[01:29:31.250]                   function(frame = 1L) {
[01:29:31.250]                     if (is.function(sendCondition)) 
[01:29:31.250]                       return(sendCondition)
[01:29:31.250]                     ns <- getNamespace("parallel")
[01:29:31.250]                     if (exists("sendData", mode = "function", 
[01:29:31.250]                       envir = ns)) {
[01:29:31.250]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:31.250]                         envir = ns)
[01:29:31.250]                       envir <- sys.frame(frame)
[01:29:31.250]                       master <- NULL
[01:29:31.250]                       while (!identical(envir, .GlobalEnv) && 
[01:29:31.250]                         !identical(envir, emptyenv())) {
[01:29:31.250]                         if (exists("master", mode = "list", envir = envir, 
[01:29:31.250]                           inherits = FALSE)) {
[01:29:31.250]                           master <- get("master", mode = "list", 
[01:29:31.250]                             envir = envir, inherits = FALSE)
[01:29:31.250]                           if (inherits(master, c("SOCKnode", 
[01:29:31.250]                             "SOCK0node"))) {
[01:29:31.250]                             sendCondition <<- function(cond) {
[01:29:31.250]                               data <- list(type = "VALUE", value = cond, 
[01:29:31.250]                                 success = TRUE)
[01:29:31.250]                               parallel_sendData(master, data)
[01:29:31.250]                             }
[01:29:31.250]                             return(sendCondition)
[01:29:31.250]                           }
[01:29:31.250]                         }
[01:29:31.250]                         frame <- frame + 1L
[01:29:31.250]                         envir <- sys.frame(frame)
[01:29:31.250]                       }
[01:29:31.250]                     }
[01:29:31.250]                     sendCondition <<- function(cond) NULL
[01:29:31.250]                   }
[01:29:31.250]                 })
[01:29:31.250]                 withCallingHandlers({
[01:29:31.250]                   {
[01:29:31.250]                     sample(x, size = 1L)
[01:29:31.250]                   }
[01:29:31.250]                 }, immediateCondition = function(cond) {
[01:29:31.250]                   sendCondition <- ...future.makeSendCondition()
[01:29:31.250]                   sendCondition(cond)
[01:29:31.250]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.250]                   {
[01:29:31.250]                     inherits <- base::inherits
[01:29:31.250]                     invokeRestart <- base::invokeRestart
[01:29:31.250]                     is.null <- base::is.null
[01:29:31.250]                     muffled <- FALSE
[01:29:31.250]                     if (inherits(cond, "message")) {
[01:29:31.250]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:31.250]                       if (muffled) 
[01:29:31.250]                         invokeRestart("muffleMessage")
[01:29:31.250]                     }
[01:29:31.250]                     else if (inherits(cond, "warning")) {
[01:29:31.250]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:31.250]                       if (muffled) 
[01:29:31.250]                         invokeRestart("muffleWarning")
[01:29:31.250]                     }
[01:29:31.250]                     else if (inherits(cond, "condition")) {
[01:29:31.250]                       if (!is.null(pattern)) {
[01:29:31.250]                         computeRestarts <- base::computeRestarts
[01:29:31.250]                         grepl <- base::grepl
[01:29:31.250]                         restarts <- computeRestarts(cond)
[01:29:31.250]                         for (restart in restarts) {
[01:29:31.250]                           name <- restart$name
[01:29:31.250]                           if (is.null(name)) 
[01:29:31.250]                             next
[01:29:31.250]                           if (!grepl(pattern, name)) 
[01:29:31.250]                             next
[01:29:31.250]                           invokeRestart(restart)
[01:29:31.250]                           muffled <- TRUE
[01:29:31.250]                           break
[01:29:31.250]                         }
[01:29:31.250]                       }
[01:29:31.250]                     }
[01:29:31.250]                     invisible(muffled)
[01:29:31.250]                   }
[01:29:31.250]                   muffleCondition(cond)
[01:29:31.250]                 })
[01:29:31.250]             }))
[01:29:31.250]             future::FutureResult(value = ...future.value$value, 
[01:29:31.250]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.250]                   ...future.rng), globalenv = if (FALSE) 
[01:29:31.250]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:31.250]                     ...future.globalenv.names))
[01:29:31.250]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:31.250]         }, condition = base::local({
[01:29:31.250]             c <- base::c
[01:29:31.250]             inherits <- base::inherits
[01:29:31.250]             invokeRestart <- base::invokeRestart
[01:29:31.250]             length <- base::length
[01:29:31.250]             list <- base::list
[01:29:31.250]             seq.int <- base::seq.int
[01:29:31.250]             signalCondition <- base::signalCondition
[01:29:31.250]             sys.calls <- base::sys.calls
[01:29:31.250]             `[[` <- base::`[[`
[01:29:31.250]             `+` <- base::`+`
[01:29:31.250]             `<<-` <- base::`<<-`
[01:29:31.250]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:31.250]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:31.250]                   3L)]
[01:29:31.250]             }
[01:29:31.250]             function(cond) {
[01:29:31.250]                 is_error <- inherits(cond, "error")
[01:29:31.250]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:31.250]                   NULL)
[01:29:31.250]                 if (is_error) {
[01:29:31.250]                   sessionInformation <- function() {
[01:29:31.250]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:31.250]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:31.250]                       search = base::search(), system = base::Sys.info())
[01:29:31.250]                   }
[01:29:31.250]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.250]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:31.250]                     cond$call), session = sessionInformation(), 
[01:29:31.250]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:31.250]                   signalCondition(cond)
[01:29:31.250]                 }
[01:29:31.250]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:31.250]                 "immediateCondition"))) {
[01:29:31.250]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:31.250]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.250]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:31.250]                   if (TRUE && !signal) {
[01:29:31.250]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.250]                     {
[01:29:31.250]                       inherits <- base::inherits
[01:29:31.250]                       invokeRestart <- base::invokeRestart
[01:29:31.250]                       is.null <- base::is.null
[01:29:31.250]                       muffled <- FALSE
[01:29:31.250]                       if (inherits(cond, "message")) {
[01:29:31.250]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.250]                         if (muffled) 
[01:29:31.250]                           invokeRestart("muffleMessage")
[01:29:31.250]                       }
[01:29:31.250]                       else if (inherits(cond, "warning")) {
[01:29:31.250]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.250]                         if (muffled) 
[01:29:31.250]                           invokeRestart("muffleWarning")
[01:29:31.250]                       }
[01:29:31.250]                       else if (inherits(cond, "condition")) {
[01:29:31.250]                         if (!is.null(pattern)) {
[01:29:31.250]                           computeRestarts <- base::computeRestarts
[01:29:31.250]                           grepl <- base::grepl
[01:29:31.250]                           restarts <- computeRestarts(cond)
[01:29:31.250]                           for (restart in restarts) {
[01:29:31.250]                             name <- restart$name
[01:29:31.250]                             if (is.null(name)) 
[01:29:31.250]                               next
[01:29:31.250]                             if (!grepl(pattern, name)) 
[01:29:31.250]                               next
[01:29:31.250]                             invokeRestart(restart)
[01:29:31.250]                             muffled <- TRUE
[01:29:31.250]                             break
[01:29:31.250]                           }
[01:29:31.250]                         }
[01:29:31.250]                       }
[01:29:31.250]                       invisible(muffled)
[01:29:31.250]                     }
[01:29:31.250]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.250]                   }
[01:29:31.250]                 }
[01:29:31.250]                 else {
[01:29:31.250]                   if (TRUE) {
[01:29:31.250]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.250]                     {
[01:29:31.250]                       inherits <- base::inherits
[01:29:31.250]                       invokeRestart <- base::invokeRestart
[01:29:31.250]                       is.null <- base::is.null
[01:29:31.250]                       muffled <- FALSE
[01:29:31.250]                       if (inherits(cond, "message")) {
[01:29:31.250]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.250]                         if (muffled) 
[01:29:31.250]                           invokeRestart("muffleMessage")
[01:29:31.250]                       }
[01:29:31.250]                       else if (inherits(cond, "warning")) {
[01:29:31.250]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.250]                         if (muffled) 
[01:29:31.250]                           invokeRestart("muffleWarning")
[01:29:31.250]                       }
[01:29:31.250]                       else if (inherits(cond, "condition")) {
[01:29:31.250]                         if (!is.null(pattern)) {
[01:29:31.250]                           computeRestarts <- base::computeRestarts
[01:29:31.250]                           grepl <- base::grepl
[01:29:31.250]                           restarts <- computeRestarts(cond)
[01:29:31.250]                           for (restart in restarts) {
[01:29:31.250]                             name <- restart$name
[01:29:31.250]                             if (is.null(name)) 
[01:29:31.250]                               next
[01:29:31.250]                             if (!grepl(pattern, name)) 
[01:29:31.250]                               next
[01:29:31.250]                             invokeRestart(restart)
[01:29:31.250]                             muffled <- TRUE
[01:29:31.250]                             break
[01:29:31.250]                           }
[01:29:31.250]                         }
[01:29:31.250]                       }
[01:29:31.250]                       invisible(muffled)
[01:29:31.250]                     }
[01:29:31.250]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.250]                   }
[01:29:31.250]                 }
[01:29:31.250]             }
[01:29:31.250]         }))
[01:29:31.250]     }, error = function(ex) {
[01:29:31.250]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:31.250]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.250]                 ...future.rng), started = ...future.startTime, 
[01:29:31.250]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:31.250]             version = "1.8"), class = "FutureResult")
[01:29:31.250]     }, finally = {
[01:29:31.250]         if (!identical(...future.workdir, getwd())) 
[01:29:31.250]             setwd(...future.workdir)
[01:29:31.250]         {
[01:29:31.250]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:31.250]                 ...future.oldOptions$nwarnings <- NULL
[01:29:31.250]             }
[01:29:31.250]             base::options(...future.oldOptions)
[01:29:31.250]             if (.Platform$OS.type == "windows") {
[01:29:31.250]                 old_names <- names(...future.oldEnvVars)
[01:29:31.250]                 envs <- base::Sys.getenv()
[01:29:31.250]                 names <- names(envs)
[01:29:31.250]                 common <- intersect(names, old_names)
[01:29:31.250]                 added <- setdiff(names, old_names)
[01:29:31.250]                 removed <- setdiff(old_names, names)
[01:29:31.250]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:31.250]                   envs[common]]
[01:29:31.250]                 NAMES <- toupper(changed)
[01:29:31.250]                 args <- list()
[01:29:31.250]                 for (kk in seq_along(NAMES)) {
[01:29:31.250]                   name <- changed[[kk]]
[01:29:31.250]                   NAME <- NAMES[[kk]]
[01:29:31.250]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.250]                     next
[01:29:31.250]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.250]                 }
[01:29:31.250]                 NAMES <- toupper(added)
[01:29:31.250]                 for (kk in seq_along(NAMES)) {
[01:29:31.250]                   name <- added[[kk]]
[01:29:31.250]                   NAME <- NAMES[[kk]]
[01:29:31.250]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.250]                     next
[01:29:31.250]                   args[[name]] <- ""
[01:29:31.250]                 }
[01:29:31.250]                 NAMES <- toupper(removed)
[01:29:31.250]                 for (kk in seq_along(NAMES)) {
[01:29:31.250]                   name <- removed[[kk]]
[01:29:31.250]                   NAME <- NAMES[[kk]]
[01:29:31.250]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.250]                     next
[01:29:31.250]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.250]                 }
[01:29:31.250]                 if (length(args) > 0) 
[01:29:31.250]                   base::do.call(base::Sys.setenv, args = args)
[01:29:31.250]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:31.250]             }
[01:29:31.250]             else {
[01:29:31.250]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:31.250]             }
[01:29:31.250]             {
[01:29:31.250]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:31.250]                   0L) {
[01:29:31.250]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:31.250]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:31.250]                   base::options(opts)
[01:29:31.250]                 }
[01:29:31.250]                 {
[01:29:31.250]                   {
[01:29:31.250]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:31.250]                     NULL
[01:29:31.250]                   }
[01:29:31.250]                   options(future.plan = NULL)
[01:29:31.250]                   if (is.na(NA_character_)) 
[01:29:31.250]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.250]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:31.250]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:31.250]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:31.250]                     envir = parent.frame()) 
[01:29:31.250]                   {
[01:29:31.250]                     if (is.function(workers)) 
[01:29:31.250]                       workers <- workers()
[01:29:31.250]                     workers <- structure(as.integer(workers), 
[01:29:31.250]                       class = class(workers))
[01:29:31.250]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:31.250]                       workers >= 1)
[01:29:31.250]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:31.250]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:31.250]                     }
[01:29:31.250]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:31.250]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:31.250]                       envir = envir)
[01:29:31.250]                     if (!future$lazy) 
[01:29:31.250]                       future <- run(future)
[01:29:31.250]                     invisible(future)
[01:29:31.250]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:31.250]                 }
[01:29:31.250]             }
[01:29:31.250]         }
[01:29:31.250]     })
[01:29:31.250]     if (TRUE) {
[01:29:31.250]         base::sink(type = "output", split = FALSE)
[01:29:31.250]         if (TRUE) {
[01:29:31.250]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:31.250]         }
[01:29:31.250]         else {
[01:29:31.250]             ...future.result["stdout"] <- base::list(NULL)
[01:29:31.250]         }
[01:29:31.250]         base::close(...future.stdout)
[01:29:31.250]         ...future.stdout <- NULL
[01:29:31.250]     }
[01:29:31.250]     ...future.result$conditions <- ...future.conditions
[01:29:31.250]     ...future.result$finished <- base::Sys.time()
[01:29:31.250]     ...future.result
[01:29:31.250] }
[01:29:31.255] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:31.256] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:31.256] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:31.256] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:31.257] MultisessionFuture started
[01:29:31.257] - Launch lazy future ... done
[01:29:31.258] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_3-593436'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b970322ab0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[01:29:31.274] receiveMessageFromWorker() for ClusterFuture ...
[01:29:31.274] - Validating connection of MultisessionFuture
[01:29:31.275] - received message: FutureResult
[01:29:31.275] - Received FutureResult
[01:29:31.275] - Erased future from FutureRegistry
[01:29:31.275] result() for ClusterFuture ...
[01:29:31.275] - result already collected: FutureResult
[01:29:31.276] result() for ClusterFuture ... done
[01:29:31.276] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.276] getGlobalsAndPackages() ...
[01:29:31.276] Searching for globals...
[01:29:31.278] - globals found: [3] '{', 'sample', 'x'
[01:29:31.278] Searching for globals ... DONE
[01:29:31.278] Resolving globals: FALSE
[01:29:31.278] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:31.279] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:31.279] - globals: [1] 'x'
[01:29:31.279] 
[01:29:31.280] getGlobalsAndPackages() ... DONE
[01:29:31.280] run() for 'Future' ...
[01:29:31.280] - state: 'created'
[01:29:31.280] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:31.295] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.295] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:31.295]   - Field: 'node'
[01:29:31.295]   - Field: 'label'
[01:29:31.296]   - Field: 'local'
[01:29:31.296]   - Field: 'owner'
[01:29:31.296]   - Field: 'envir'
[01:29:31.296]   - Field: 'workers'
[01:29:31.296]   - Field: 'packages'
[01:29:31.297]   - Field: 'gc'
[01:29:31.297]   - Field: 'conditions'
[01:29:31.297]   - Field: 'persistent'
[01:29:31.297]   - Field: 'expr'
[01:29:31.297]   - Field: 'uuid'
[01:29:31.297]   - Field: 'seed'
[01:29:31.298]   - Field: 'version'
[01:29:31.298]   - Field: 'result'
[01:29:31.298]   - Field: 'asynchronous'
[01:29:31.298]   - Field: 'calls'
[01:29:31.298]   - Field: 'globals'
[01:29:31.299]   - Field: 'stdout'
[01:29:31.299]   - Field: 'earlySignal'
[01:29:31.299]   - Field: 'lazy'
[01:29:31.299]   - Field: 'state'
[01:29:31.299] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:31.300] - Launch lazy future ...
[01:29:31.300] Packages needed by the future expression (n = 0): <none>
[01:29:31.300] Packages needed by future strategies (n = 0): <none>
[01:29:31.301] {
[01:29:31.301]     {
[01:29:31.301]         {
[01:29:31.301]             ...future.startTime <- base::Sys.time()
[01:29:31.301]             {
[01:29:31.301]                 {
[01:29:31.301]                   {
[01:29:31.301]                     {
[01:29:31.301]                       base::local({
[01:29:31.301]                         has_future <- base::requireNamespace("future", 
[01:29:31.301]                           quietly = TRUE)
[01:29:31.301]                         if (has_future) {
[01:29:31.301]                           ns <- base::getNamespace("future")
[01:29:31.301]                           version <- ns[[".package"]][["version"]]
[01:29:31.301]                           if (is.null(version)) 
[01:29:31.301]                             version <- utils::packageVersion("future")
[01:29:31.301]                         }
[01:29:31.301]                         else {
[01:29:31.301]                           version <- NULL
[01:29:31.301]                         }
[01:29:31.301]                         if (!has_future || version < "1.8.0") {
[01:29:31.301]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:31.301]                             "", base::R.version$version.string), 
[01:29:31.301]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:31.301]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:31.301]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:31.301]                               "release", "version")], collapse = " "), 
[01:29:31.301]                             hostname = base::Sys.info()[["nodename"]])
[01:29:31.301]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:31.301]                             info)
[01:29:31.301]                           info <- base::paste(info, collapse = "; ")
[01:29:31.301]                           if (!has_future) {
[01:29:31.301]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:31.301]                               info)
[01:29:31.301]                           }
[01:29:31.301]                           else {
[01:29:31.301]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:31.301]                               info, version)
[01:29:31.301]                           }
[01:29:31.301]                           base::stop(msg)
[01:29:31.301]                         }
[01:29:31.301]                       })
[01:29:31.301]                     }
[01:29:31.301]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:31.301]                     base::options(mc.cores = 1L)
[01:29:31.301]                   }
[01:29:31.301]                   options(future.plan = NULL)
[01:29:31.301]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.301]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:31.301]                 }
[01:29:31.301]                 ...future.workdir <- getwd()
[01:29:31.301]             }
[01:29:31.301]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:31.301]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:31.301]         }
[01:29:31.301]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:31.301]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:31.301]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:31.301]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:31.301]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:31.301]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:31.301]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:31.301]             base::names(...future.oldOptions))
[01:29:31.301]     }
[01:29:31.301]     if (FALSE) {
[01:29:31.301]     }
[01:29:31.301]     else {
[01:29:31.301]         if (TRUE) {
[01:29:31.301]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:31.301]                 open = "w")
[01:29:31.301]         }
[01:29:31.301]         else {
[01:29:31.301]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:31.301]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:31.301]         }
[01:29:31.301]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:31.301]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:31.301]             base::sink(type = "output", split = FALSE)
[01:29:31.301]             base::close(...future.stdout)
[01:29:31.301]         }, add = TRUE)
[01:29:31.301]     }
[01:29:31.301]     ...future.frame <- base::sys.nframe()
[01:29:31.301]     ...future.conditions <- base::list()
[01:29:31.301]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:31.301]     if (FALSE) {
[01:29:31.301]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:31.301]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:31.301]     }
[01:29:31.301]     ...future.result <- base::tryCatch({
[01:29:31.301]         base::withCallingHandlers({
[01:29:31.301]             ...future.value <- base::withVisible(base::local({
[01:29:31.301]                 ...future.makeSendCondition <- base::local({
[01:29:31.301]                   sendCondition <- NULL
[01:29:31.301]                   function(frame = 1L) {
[01:29:31.301]                     if (is.function(sendCondition)) 
[01:29:31.301]                       return(sendCondition)
[01:29:31.301]                     ns <- getNamespace("parallel")
[01:29:31.301]                     if (exists("sendData", mode = "function", 
[01:29:31.301]                       envir = ns)) {
[01:29:31.301]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:31.301]                         envir = ns)
[01:29:31.301]                       envir <- sys.frame(frame)
[01:29:31.301]                       master <- NULL
[01:29:31.301]                       while (!identical(envir, .GlobalEnv) && 
[01:29:31.301]                         !identical(envir, emptyenv())) {
[01:29:31.301]                         if (exists("master", mode = "list", envir = envir, 
[01:29:31.301]                           inherits = FALSE)) {
[01:29:31.301]                           master <- get("master", mode = "list", 
[01:29:31.301]                             envir = envir, inherits = FALSE)
[01:29:31.301]                           if (inherits(master, c("SOCKnode", 
[01:29:31.301]                             "SOCK0node"))) {
[01:29:31.301]                             sendCondition <<- function(cond) {
[01:29:31.301]                               data <- list(type = "VALUE", value = cond, 
[01:29:31.301]                                 success = TRUE)
[01:29:31.301]                               parallel_sendData(master, data)
[01:29:31.301]                             }
[01:29:31.301]                             return(sendCondition)
[01:29:31.301]                           }
[01:29:31.301]                         }
[01:29:31.301]                         frame <- frame + 1L
[01:29:31.301]                         envir <- sys.frame(frame)
[01:29:31.301]                       }
[01:29:31.301]                     }
[01:29:31.301]                     sendCondition <<- function(cond) NULL
[01:29:31.301]                   }
[01:29:31.301]                 })
[01:29:31.301]                 withCallingHandlers({
[01:29:31.301]                   {
[01:29:31.301]                     sample(x, size = 1L)
[01:29:31.301]                   }
[01:29:31.301]                 }, immediateCondition = function(cond) {
[01:29:31.301]                   sendCondition <- ...future.makeSendCondition()
[01:29:31.301]                   sendCondition(cond)
[01:29:31.301]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.301]                   {
[01:29:31.301]                     inherits <- base::inherits
[01:29:31.301]                     invokeRestart <- base::invokeRestart
[01:29:31.301]                     is.null <- base::is.null
[01:29:31.301]                     muffled <- FALSE
[01:29:31.301]                     if (inherits(cond, "message")) {
[01:29:31.301]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:31.301]                       if (muffled) 
[01:29:31.301]                         invokeRestart("muffleMessage")
[01:29:31.301]                     }
[01:29:31.301]                     else if (inherits(cond, "warning")) {
[01:29:31.301]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:31.301]                       if (muffled) 
[01:29:31.301]                         invokeRestart("muffleWarning")
[01:29:31.301]                     }
[01:29:31.301]                     else if (inherits(cond, "condition")) {
[01:29:31.301]                       if (!is.null(pattern)) {
[01:29:31.301]                         computeRestarts <- base::computeRestarts
[01:29:31.301]                         grepl <- base::grepl
[01:29:31.301]                         restarts <- computeRestarts(cond)
[01:29:31.301]                         for (restart in restarts) {
[01:29:31.301]                           name <- restart$name
[01:29:31.301]                           if (is.null(name)) 
[01:29:31.301]                             next
[01:29:31.301]                           if (!grepl(pattern, name)) 
[01:29:31.301]                             next
[01:29:31.301]                           invokeRestart(restart)
[01:29:31.301]                           muffled <- TRUE
[01:29:31.301]                           break
[01:29:31.301]                         }
[01:29:31.301]                       }
[01:29:31.301]                     }
[01:29:31.301]                     invisible(muffled)
[01:29:31.301]                   }
[01:29:31.301]                   muffleCondition(cond)
[01:29:31.301]                 })
[01:29:31.301]             }))
[01:29:31.301]             future::FutureResult(value = ...future.value$value, 
[01:29:31.301]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.301]                   ...future.rng), globalenv = if (FALSE) 
[01:29:31.301]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:31.301]                     ...future.globalenv.names))
[01:29:31.301]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:31.301]         }, condition = base::local({
[01:29:31.301]             c <- base::c
[01:29:31.301]             inherits <- base::inherits
[01:29:31.301]             invokeRestart <- base::invokeRestart
[01:29:31.301]             length <- base::length
[01:29:31.301]             list <- base::list
[01:29:31.301]             seq.int <- base::seq.int
[01:29:31.301]             signalCondition <- base::signalCondition
[01:29:31.301]             sys.calls <- base::sys.calls
[01:29:31.301]             `[[` <- base::`[[`
[01:29:31.301]             `+` <- base::`+`
[01:29:31.301]             `<<-` <- base::`<<-`
[01:29:31.301]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:31.301]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:31.301]                   3L)]
[01:29:31.301]             }
[01:29:31.301]             function(cond) {
[01:29:31.301]                 is_error <- inherits(cond, "error")
[01:29:31.301]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:31.301]                   NULL)
[01:29:31.301]                 if (is_error) {
[01:29:31.301]                   sessionInformation <- function() {
[01:29:31.301]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:31.301]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:31.301]                       search = base::search(), system = base::Sys.info())
[01:29:31.301]                   }
[01:29:31.301]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.301]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:31.301]                     cond$call), session = sessionInformation(), 
[01:29:31.301]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:31.301]                   signalCondition(cond)
[01:29:31.301]                 }
[01:29:31.301]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:31.301]                 "immediateCondition"))) {
[01:29:31.301]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:31.301]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.301]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:31.301]                   if (TRUE && !signal) {
[01:29:31.301]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.301]                     {
[01:29:31.301]                       inherits <- base::inherits
[01:29:31.301]                       invokeRestart <- base::invokeRestart
[01:29:31.301]                       is.null <- base::is.null
[01:29:31.301]                       muffled <- FALSE
[01:29:31.301]                       if (inherits(cond, "message")) {
[01:29:31.301]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.301]                         if (muffled) 
[01:29:31.301]                           invokeRestart("muffleMessage")
[01:29:31.301]                       }
[01:29:31.301]                       else if (inherits(cond, "warning")) {
[01:29:31.301]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.301]                         if (muffled) 
[01:29:31.301]                           invokeRestart("muffleWarning")
[01:29:31.301]                       }
[01:29:31.301]                       else if (inherits(cond, "condition")) {
[01:29:31.301]                         if (!is.null(pattern)) {
[01:29:31.301]                           computeRestarts <- base::computeRestarts
[01:29:31.301]                           grepl <- base::grepl
[01:29:31.301]                           restarts <- computeRestarts(cond)
[01:29:31.301]                           for (restart in restarts) {
[01:29:31.301]                             name <- restart$name
[01:29:31.301]                             if (is.null(name)) 
[01:29:31.301]                               next
[01:29:31.301]                             if (!grepl(pattern, name)) 
[01:29:31.301]                               next
[01:29:31.301]                             invokeRestart(restart)
[01:29:31.301]                             muffled <- TRUE
[01:29:31.301]                             break
[01:29:31.301]                           }
[01:29:31.301]                         }
[01:29:31.301]                       }
[01:29:31.301]                       invisible(muffled)
[01:29:31.301]                     }
[01:29:31.301]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.301]                   }
[01:29:31.301]                 }
[01:29:31.301]                 else {
[01:29:31.301]                   if (TRUE) {
[01:29:31.301]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.301]                     {
[01:29:31.301]                       inherits <- base::inherits
[01:29:31.301]                       invokeRestart <- base::invokeRestart
[01:29:31.301]                       is.null <- base::is.null
[01:29:31.301]                       muffled <- FALSE
[01:29:31.301]                       if (inherits(cond, "message")) {
[01:29:31.301]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.301]                         if (muffled) 
[01:29:31.301]                           invokeRestart("muffleMessage")
[01:29:31.301]                       }
[01:29:31.301]                       else if (inherits(cond, "warning")) {
[01:29:31.301]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.301]                         if (muffled) 
[01:29:31.301]                           invokeRestart("muffleWarning")
[01:29:31.301]                       }
[01:29:31.301]                       else if (inherits(cond, "condition")) {
[01:29:31.301]                         if (!is.null(pattern)) {
[01:29:31.301]                           computeRestarts <- base::computeRestarts
[01:29:31.301]                           grepl <- base::grepl
[01:29:31.301]                           restarts <- computeRestarts(cond)
[01:29:31.301]                           for (restart in restarts) {
[01:29:31.301]                             name <- restart$name
[01:29:31.301]                             if (is.null(name)) 
[01:29:31.301]                               next
[01:29:31.301]                             if (!grepl(pattern, name)) 
[01:29:31.301]                               next
[01:29:31.301]                             invokeRestart(restart)
[01:29:31.301]                             muffled <- TRUE
[01:29:31.301]                             break
[01:29:31.301]                           }
[01:29:31.301]                         }
[01:29:31.301]                       }
[01:29:31.301]                       invisible(muffled)
[01:29:31.301]                     }
[01:29:31.301]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.301]                   }
[01:29:31.301]                 }
[01:29:31.301]             }
[01:29:31.301]         }))
[01:29:31.301]     }, error = function(ex) {
[01:29:31.301]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:31.301]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.301]                 ...future.rng), started = ...future.startTime, 
[01:29:31.301]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:31.301]             version = "1.8"), class = "FutureResult")
[01:29:31.301]     }, finally = {
[01:29:31.301]         if (!identical(...future.workdir, getwd())) 
[01:29:31.301]             setwd(...future.workdir)
[01:29:31.301]         {
[01:29:31.301]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:31.301]                 ...future.oldOptions$nwarnings <- NULL
[01:29:31.301]             }
[01:29:31.301]             base::options(...future.oldOptions)
[01:29:31.301]             if (.Platform$OS.type == "windows") {
[01:29:31.301]                 old_names <- names(...future.oldEnvVars)
[01:29:31.301]                 envs <- base::Sys.getenv()
[01:29:31.301]                 names <- names(envs)
[01:29:31.301]                 common <- intersect(names, old_names)
[01:29:31.301]                 added <- setdiff(names, old_names)
[01:29:31.301]                 removed <- setdiff(old_names, names)
[01:29:31.301]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:31.301]                   envs[common]]
[01:29:31.301]                 NAMES <- toupper(changed)
[01:29:31.301]                 args <- list()
[01:29:31.301]                 for (kk in seq_along(NAMES)) {
[01:29:31.301]                   name <- changed[[kk]]
[01:29:31.301]                   NAME <- NAMES[[kk]]
[01:29:31.301]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.301]                     next
[01:29:31.301]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.301]                 }
[01:29:31.301]                 NAMES <- toupper(added)
[01:29:31.301]                 for (kk in seq_along(NAMES)) {
[01:29:31.301]                   name <- added[[kk]]
[01:29:31.301]                   NAME <- NAMES[[kk]]
[01:29:31.301]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.301]                     next
[01:29:31.301]                   args[[name]] <- ""
[01:29:31.301]                 }
[01:29:31.301]                 NAMES <- toupper(removed)
[01:29:31.301]                 for (kk in seq_along(NAMES)) {
[01:29:31.301]                   name <- removed[[kk]]
[01:29:31.301]                   NAME <- NAMES[[kk]]
[01:29:31.301]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.301]                     next
[01:29:31.301]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.301]                 }
[01:29:31.301]                 if (length(args) > 0) 
[01:29:31.301]                   base::do.call(base::Sys.setenv, args = args)
[01:29:31.301]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:31.301]             }
[01:29:31.301]             else {
[01:29:31.301]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:31.301]             }
[01:29:31.301]             {
[01:29:31.301]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:31.301]                   0L) {
[01:29:31.301]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:31.301]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:31.301]                   base::options(opts)
[01:29:31.301]                 }
[01:29:31.301]                 {
[01:29:31.301]                   {
[01:29:31.301]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:31.301]                     NULL
[01:29:31.301]                   }
[01:29:31.301]                   options(future.plan = NULL)
[01:29:31.301]                   if (is.na(NA_character_)) 
[01:29:31.301]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.301]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:31.301]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:31.301]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:31.301]                     envir = parent.frame()) 
[01:29:31.301]                   {
[01:29:31.301]                     if (is.function(workers)) 
[01:29:31.301]                       workers <- workers()
[01:29:31.301]                     workers <- structure(as.integer(workers), 
[01:29:31.301]                       class = class(workers))
[01:29:31.301]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:31.301]                       workers >= 1)
[01:29:31.301]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:31.301]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:31.301]                     }
[01:29:31.301]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:31.301]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:31.301]                       envir = envir)
[01:29:31.301]                     if (!future$lazy) 
[01:29:31.301]                       future <- run(future)
[01:29:31.301]                     invisible(future)
[01:29:31.301]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:31.301]                 }
[01:29:31.301]             }
[01:29:31.301]         }
[01:29:31.301]     })
[01:29:31.301]     if (TRUE) {
[01:29:31.301]         base::sink(type = "output", split = FALSE)
[01:29:31.301]         if (TRUE) {
[01:29:31.301]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:31.301]         }
[01:29:31.301]         else {
[01:29:31.301]             ...future.result["stdout"] <- base::list(NULL)
[01:29:31.301]         }
[01:29:31.301]         base::close(...future.stdout)
[01:29:31.301]         ...future.stdout <- NULL
[01:29:31.301]     }
[01:29:31.301]     ...future.result$conditions <- ...future.conditions
[01:29:31.301]     ...future.result$finished <- base::Sys.time()
[01:29:31.301]     ...future.result
[01:29:31.301] }
[01:29:31.306] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:31.306] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:31.308] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:31.308] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:31.309] MultisessionFuture started
[01:29:31.309] - Launch lazy future ... done
[01:29:31.310] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_4-115905'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b970322ab0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[01:29:31.326] receiveMessageFromWorker() for ClusterFuture ...
[01:29:31.326] - Validating connection of MultisessionFuture
[01:29:31.326] - received message: FutureResult
[01:29:31.326] - Received FutureResult
[01:29:31.327] - Erased future from FutureRegistry
[01:29:31.327] result() for ClusterFuture ...
[01:29:31.327] - result already collected: FutureResult
[01:29:31.327] result() for ClusterFuture ... done
[01:29:31.327] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.328] resolve() on list ...
[01:29:31.328]  recursive: 0
[01:29:31.328]  length: 4
[01:29:31.328] 
[01:29:31.329] Future #1
[01:29:31.329] result() for ClusterFuture ...
[01:29:31.329] - result already collected: FutureResult
[01:29:31.329] result() for ClusterFuture ... done
[01:29:31.329] result() for ClusterFuture ...
[01:29:31.329] - result already collected: FutureResult
[01:29:31.329] result() for ClusterFuture ... done
[01:29:31.330] signalConditionsASAP(MultisessionFuture, pos=1) ...
[01:29:31.330] - nx: 4
[01:29:31.330] - relay: TRUE
[01:29:31.330] - stdout: TRUE
[01:29:31.331] - signal: TRUE
[01:29:31.331] - resignal: FALSE
[01:29:31.331] - force: TRUE
[01:29:31.331] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:31.331] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:31.331]  - until=1
[01:29:31.332]  - relaying element #1
[01:29:31.332] result() for ClusterFuture ...
[01:29:31.332] - result already collected: FutureResult
[01:29:31.332] result() for ClusterFuture ... done
[01:29:31.332] result() for ClusterFuture ...
[01:29:31.332] - result already collected: FutureResult
[01:29:31.333] result() for ClusterFuture ... done
[01:29:31.333] signalConditions() ...
[01:29:31.333]  - include = 'immediateCondition'
[01:29:31.333]  - exclude = 
[01:29:31.333]  - resignal = FALSE
[01:29:31.333]  - Number of conditions: 1
[01:29:31.334] signalConditions() ... done
[01:29:31.334] result() for ClusterFuture ...
[01:29:31.334] - result already collected: FutureResult
[01:29:31.334] result() for ClusterFuture ... done
[01:29:31.334] signalConditions() ...
[01:29:31.334]  - include = 'immediateCondition'
[01:29:31.335]  - exclude = 
[01:29:31.335]  - resignal = FALSE
[01:29:31.335]  - Number of conditions: 1
[01:29:31.335] signalConditions() ... done
[01:29:31.335] result() for ClusterFuture ...
[01:29:31.335] - result already collected: FutureResult
[01:29:31.336] result() for ClusterFuture ... done
[01:29:31.336] signalConditions() ...
[01:29:31.336]  - include = 'condition'
[01:29:31.336]  - exclude = 'immediateCondition'
[01:29:31.336]  - resignal = TRUE
[01:29:31.336]  - Number of conditions: 1
[01:29:31.337]  - Condition #1: 'RngFutureError', 'FutureError', 'error', 'RngFutureCondition', 'FutureCondition', 'condition'
[01:29:31.337] signalConditions() ... done
[01:29:31.337] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:31.337] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:31.337] signalConditionsASAP(MultisessionFuture, pos=1) ... done
<RngFutureError: UNRELIABLE VALUE: Future ('fsample_1-249481') unexpectedly generated random numbers without specifying argument 'seed'. There is a risk that those random numbers are not statistically sound and the overall results might be invalid. To fix this, specify 'seed=TRUE'. This ensures that proper, parallel-safe random numbers are produced via the L'Ecuyer-CMRG method. To disable this check, use 'seed=NULL', or set option 'future.rng.onMisuse' to "ignore".>


Future UUID: 79b3301e-d265-407c-18a5-79e0aeaffedb


DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
MultisessionFuture:
Label: 'fsample_1-249481'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b970322ab0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Conditions captured: [n=1] 'RngFutureError'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'

DEBUG: END TROUBLESHOOTING HELP
[01:29:31.339] getGlobalsAndPackages() ...
[01:29:31.339] Searching for globals...
[01:29:31.340] - globals found: [3] '{', 'sample', 'x'
[01:29:31.340] Searching for globals ... DONE
[01:29:31.340] Resolving globals: FALSE
[01:29:31.341] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:31.341] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:31.342] - globals: [1] 'x'
[01:29:31.342] 
[01:29:31.342] getGlobalsAndPackages() ... DONE
[01:29:31.342] run() for 'Future' ...
[01:29:31.343] - state: 'created'
[01:29:31.343] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:31.357] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.357] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:31.357]   - Field: 'node'
[01:29:31.358]   - Field: 'label'
[01:29:31.358]   - Field: 'local'
[01:29:31.358]   - Field: 'owner'
[01:29:31.358]   - Field: 'envir'
[01:29:31.358]   - Field: 'workers'
[01:29:31.358]   - Field: 'packages'
[01:29:31.359]   - Field: 'gc'
[01:29:31.359]   - Field: 'conditions'
[01:29:31.359]   - Field: 'persistent'
[01:29:31.359]   - Field: 'expr'
[01:29:31.359]   - Field: 'uuid'
[01:29:31.360]   - Field: 'seed'
[01:29:31.360]   - Field: 'version'
[01:29:31.360]   - Field: 'result'
[01:29:31.360]   - Field: 'asynchronous'
[01:29:31.360]   - Field: 'calls'
[01:29:31.360]   - Field: 'globals'
[01:29:31.361]   - Field: 'stdout'
[01:29:31.361]   - Field: 'earlySignal'
[01:29:31.361]   - Field: 'lazy'
[01:29:31.361]   - Field: 'state'
[01:29:31.361] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:31.362] - Launch lazy future ...
[01:29:31.362] Packages needed by the future expression (n = 0): <none>
[01:29:31.362] Packages needed by future strategies (n = 0): <none>
[01:29:31.363] {
[01:29:31.363]     {
[01:29:31.363]         {
[01:29:31.363]             ...future.startTime <- base::Sys.time()
[01:29:31.363]             {
[01:29:31.363]                 {
[01:29:31.363]                   {
[01:29:31.363]                     {
[01:29:31.363]                       base::local({
[01:29:31.363]                         has_future <- base::requireNamespace("future", 
[01:29:31.363]                           quietly = TRUE)
[01:29:31.363]                         if (has_future) {
[01:29:31.363]                           ns <- base::getNamespace("future")
[01:29:31.363]                           version <- ns[[".package"]][["version"]]
[01:29:31.363]                           if (is.null(version)) 
[01:29:31.363]                             version <- utils::packageVersion("future")
[01:29:31.363]                         }
[01:29:31.363]                         else {
[01:29:31.363]                           version <- NULL
[01:29:31.363]                         }
[01:29:31.363]                         if (!has_future || version < "1.8.0") {
[01:29:31.363]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:31.363]                             "", base::R.version$version.string), 
[01:29:31.363]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:31.363]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:31.363]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:31.363]                               "release", "version")], collapse = " "), 
[01:29:31.363]                             hostname = base::Sys.info()[["nodename"]])
[01:29:31.363]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:31.363]                             info)
[01:29:31.363]                           info <- base::paste(info, collapse = "; ")
[01:29:31.363]                           if (!has_future) {
[01:29:31.363]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:31.363]                               info)
[01:29:31.363]                           }
[01:29:31.363]                           else {
[01:29:31.363]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:31.363]                               info, version)
[01:29:31.363]                           }
[01:29:31.363]                           base::stop(msg)
[01:29:31.363]                         }
[01:29:31.363]                       })
[01:29:31.363]                     }
[01:29:31.363]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:31.363]                     base::options(mc.cores = 1L)
[01:29:31.363]                   }
[01:29:31.363]                   options(future.plan = NULL)
[01:29:31.363]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.363]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:31.363]                 }
[01:29:31.363]                 ...future.workdir <- getwd()
[01:29:31.363]             }
[01:29:31.363]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:31.363]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:31.363]         }
[01:29:31.363]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:31.363]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:31.363]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:31.363]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:31.363]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:31.363]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:31.363]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:31.363]             base::names(...future.oldOptions))
[01:29:31.363]     }
[01:29:31.363]     if (FALSE) {
[01:29:31.363]     }
[01:29:31.363]     else {
[01:29:31.363]         if (TRUE) {
[01:29:31.363]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:31.363]                 open = "w")
[01:29:31.363]         }
[01:29:31.363]         else {
[01:29:31.363]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:31.363]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:31.363]         }
[01:29:31.363]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:31.363]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:31.363]             base::sink(type = "output", split = FALSE)
[01:29:31.363]             base::close(...future.stdout)
[01:29:31.363]         }, add = TRUE)
[01:29:31.363]     }
[01:29:31.363]     ...future.frame <- base::sys.nframe()
[01:29:31.363]     ...future.conditions <- base::list()
[01:29:31.363]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:31.363]     if (FALSE) {
[01:29:31.363]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:31.363]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:31.363]     }
[01:29:31.363]     ...future.result <- base::tryCatch({
[01:29:31.363]         base::withCallingHandlers({
[01:29:31.363]             ...future.value <- base::withVisible(base::local({
[01:29:31.363]                 ...future.makeSendCondition <- base::local({
[01:29:31.363]                   sendCondition <- NULL
[01:29:31.363]                   function(frame = 1L) {
[01:29:31.363]                     if (is.function(sendCondition)) 
[01:29:31.363]                       return(sendCondition)
[01:29:31.363]                     ns <- getNamespace("parallel")
[01:29:31.363]                     if (exists("sendData", mode = "function", 
[01:29:31.363]                       envir = ns)) {
[01:29:31.363]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:31.363]                         envir = ns)
[01:29:31.363]                       envir <- sys.frame(frame)
[01:29:31.363]                       master <- NULL
[01:29:31.363]                       while (!identical(envir, .GlobalEnv) && 
[01:29:31.363]                         !identical(envir, emptyenv())) {
[01:29:31.363]                         if (exists("master", mode = "list", envir = envir, 
[01:29:31.363]                           inherits = FALSE)) {
[01:29:31.363]                           master <- get("master", mode = "list", 
[01:29:31.363]                             envir = envir, inherits = FALSE)
[01:29:31.363]                           if (inherits(master, c("SOCKnode", 
[01:29:31.363]                             "SOCK0node"))) {
[01:29:31.363]                             sendCondition <<- function(cond) {
[01:29:31.363]                               data <- list(type = "VALUE", value = cond, 
[01:29:31.363]                                 success = TRUE)
[01:29:31.363]                               parallel_sendData(master, data)
[01:29:31.363]                             }
[01:29:31.363]                             return(sendCondition)
[01:29:31.363]                           }
[01:29:31.363]                         }
[01:29:31.363]                         frame <- frame + 1L
[01:29:31.363]                         envir <- sys.frame(frame)
[01:29:31.363]                       }
[01:29:31.363]                     }
[01:29:31.363]                     sendCondition <<- function(cond) NULL
[01:29:31.363]                   }
[01:29:31.363]                 })
[01:29:31.363]                 withCallingHandlers({
[01:29:31.363]                   {
[01:29:31.363]                     sample(x, size = 1L)
[01:29:31.363]                   }
[01:29:31.363]                 }, immediateCondition = function(cond) {
[01:29:31.363]                   sendCondition <- ...future.makeSendCondition()
[01:29:31.363]                   sendCondition(cond)
[01:29:31.363]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.363]                   {
[01:29:31.363]                     inherits <- base::inherits
[01:29:31.363]                     invokeRestart <- base::invokeRestart
[01:29:31.363]                     is.null <- base::is.null
[01:29:31.363]                     muffled <- FALSE
[01:29:31.363]                     if (inherits(cond, "message")) {
[01:29:31.363]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:31.363]                       if (muffled) 
[01:29:31.363]                         invokeRestart("muffleMessage")
[01:29:31.363]                     }
[01:29:31.363]                     else if (inherits(cond, "warning")) {
[01:29:31.363]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:31.363]                       if (muffled) 
[01:29:31.363]                         invokeRestart("muffleWarning")
[01:29:31.363]                     }
[01:29:31.363]                     else if (inherits(cond, "condition")) {
[01:29:31.363]                       if (!is.null(pattern)) {
[01:29:31.363]                         computeRestarts <- base::computeRestarts
[01:29:31.363]                         grepl <- base::grepl
[01:29:31.363]                         restarts <- computeRestarts(cond)
[01:29:31.363]                         for (restart in restarts) {
[01:29:31.363]                           name <- restart$name
[01:29:31.363]                           if (is.null(name)) 
[01:29:31.363]                             next
[01:29:31.363]                           if (!grepl(pattern, name)) 
[01:29:31.363]                             next
[01:29:31.363]                           invokeRestart(restart)
[01:29:31.363]                           muffled <- TRUE
[01:29:31.363]                           break
[01:29:31.363]                         }
[01:29:31.363]                       }
[01:29:31.363]                     }
[01:29:31.363]                     invisible(muffled)
[01:29:31.363]                   }
[01:29:31.363]                   muffleCondition(cond)
[01:29:31.363]                 })
[01:29:31.363]             }))
[01:29:31.363]             future::FutureResult(value = ...future.value$value, 
[01:29:31.363]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.363]                   ...future.rng), globalenv = if (FALSE) 
[01:29:31.363]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:31.363]                     ...future.globalenv.names))
[01:29:31.363]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:31.363]         }, condition = base::local({
[01:29:31.363]             c <- base::c
[01:29:31.363]             inherits <- base::inherits
[01:29:31.363]             invokeRestart <- base::invokeRestart
[01:29:31.363]             length <- base::length
[01:29:31.363]             list <- base::list
[01:29:31.363]             seq.int <- base::seq.int
[01:29:31.363]             signalCondition <- base::signalCondition
[01:29:31.363]             sys.calls <- base::sys.calls
[01:29:31.363]             `[[` <- base::`[[`
[01:29:31.363]             `+` <- base::`+`
[01:29:31.363]             `<<-` <- base::`<<-`
[01:29:31.363]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:31.363]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:31.363]                   3L)]
[01:29:31.363]             }
[01:29:31.363]             function(cond) {
[01:29:31.363]                 is_error <- inherits(cond, "error")
[01:29:31.363]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:31.363]                   NULL)
[01:29:31.363]                 if (is_error) {
[01:29:31.363]                   sessionInformation <- function() {
[01:29:31.363]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:31.363]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:31.363]                       search = base::search(), system = base::Sys.info())
[01:29:31.363]                   }
[01:29:31.363]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.363]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:31.363]                     cond$call), session = sessionInformation(), 
[01:29:31.363]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:31.363]                   signalCondition(cond)
[01:29:31.363]                 }
[01:29:31.363]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:31.363]                 "immediateCondition"))) {
[01:29:31.363]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:31.363]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.363]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:31.363]                   if (TRUE && !signal) {
[01:29:31.363]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.363]                     {
[01:29:31.363]                       inherits <- base::inherits
[01:29:31.363]                       invokeRestart <- base::invokeRestart
[01:29:31.363]                       is.null <- base::is.null
[01:29:31.363]                       muffled <- FALSE
[01:29:31.363]                       if (inherits(cond, "message")) {
[01:29:31.363]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.363]                         if (muffled) 
[01:29:31.363]                           invokeRestart("muffleMessage")
[01:29:31.363]                       }
[01:29:31.363]                       else if (inherits(cond, "warning")) {
[01:29:31.363]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.363]                         if (muffled) 
[01:29:31.363]                           invokeRestart("muffleWarning")
[01:29:31.363]                       }
[01:29:31.363]                       else if (inherits(cond, "condition")) {
[01:29:31.363]                         if (!is.null(pattern)) {
[01:29:31.363]                           computeRestarts <- base::computeRestarts
[01:29:31.363]                           grepl <- base::grepl
[01:29:31.363]                           restarts <- computeRestarts(cond)
[01:29:31.363]                           for (restart in restarts) {
[01:29:31.363]                             name <- restart$name
[01:29:31.363]                             if (is.null(name)) 
[01:29:31.363]                               next
[01:29:31.363]                             if (!grepl(pattern, name)) 
[01:29:31.363]                               next
[01:29:31.363]                             invokeRestart(restart)
[01:29:31.363]                             muffled <- TRUE
[01:29:31.363]                             break
[01:29:31.363]                           }
[01:29:31.363]                         }
[01:29:31.363]                       }
[01:29:31.363]                       invisible(muffled)
[01:29:31.363]                     }
[01:29:31.363]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.363]                   }
[01:29:31.363]                 }
[01:29:31.363]                 else {
[01:29:31.363]                   if (TRUE) {
[01:29:31.363]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.363]                     {
[01:29:31.363]                       inherits <- base::inherits
[01:29:31.363]                       invokeRestart <- base::invokeRestart
[01:29:31.363]                       is.null <- base::is.null
[01:29:31.363]                       muffled <- FALSE
[01:29:31.363]                       if (inherits(cond, "message")) {
[01:29:31.363]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.363]                         if (muffled) 
[01:29:31.363]                           invokeRestart("muffleMessage")
[01:29:31.363]                       }
[01:29:31.363]                       else if (inherits(cond, "warning")) {
[01:29:31.363]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.363]                         if (muffled) 
[01:29:31.363]                           invokeRestart("muffleWarning")
[01:29:31.363]                       }
[01:29:31.363]                       else if (inherits(cond, "condition")) {
[01:29:31.363]                         if (!is.null(pattern)) {
[01:29:31.363]                           computeRestarts <- base::computeRestarts
[01:29:31.363]                           grepl <- base::grepl
[01:29:31.363]                           restarts <- computeRestarts(cond)
[01:29:31.363]                           for (restart in restarts) {
[01:29:31.363]                             name <- restart$name
[01:29:31.363]                             if (is.null(name)) 
[01:29:31.363]                               next
[01:29:31.363]                             if (!grepl(pattern, name)) 
[01:29:31.363]                               next
[01:29:31.363]                             invokeRestart(restart)
[01:29:31.363]                             muffled <- TRUE
[01:29:31.363]                             break
[01:29:31.363]                           }
[01:29:31.363]                         }
[01:29:31.363]                       }
[01:29:31.363]                       invisible(muffled)
[01:29:31.363]                     }
[01:29:31.363]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.363]                   }
[01:29:31.363]                 }
[01:29:31.363]             }
[01:29:31.363]         }))
[01:29:31.363]     }, error = function(ex) {
[01:29:31.363]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:31.363]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.363]                 ...future.rng), started = ...future.startTime, 
[01:29:31.363]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:31.363]             version = "1.8"), class = "FutureResult")
[01:29:31.363]     }, finally = {
[01:29:31.363]         if (!identical(...future.workdir, getwd())) 
[01:29:31.363]             setwd(...future.workdir)
[01:29:31.363]         {
[01:29:31.363]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:31.363]                 ...future.oldOptions$nwarnings <- NULL
[01:29:31.363]             }
[01:29:31.363]             base::options(...future.oldOptions)
[01:29:31.363]             if (.Platform$OS.type == "windows") {
[01:29:31.363]                 old_names <- names(...future.oldEnvVars)
[01:29:31.363]                 envs <- base::Sys.getenv()
[01:29:31.363]                 names <- names(envs)
[01:29:31.363]                 common <- intersect(names, old_names)
[01:29:31.363]                 added <- setdiff(names, old_names)
[01:29:31.363]                 removed <- setdiff(old_names, names)
[01:29:31.363]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:31.363]                   envs[common]]
[01:29:31.363]                 NAMES <- toupper(changed)
[01:29:31.363]                 args <- list()
[01:29:31.363]                 for (kk in seq_along(NAMES)) {
[01:29:31.363]                   name <- changed[[kk]]
[01:29:31.363]                   NAME <- NAMES[[kk]]
[01:29:31.363]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.363]                     next
[01:29:31.363]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.363]                 }
[01:29:31.363]                 NAMES <- toupper(added)
[01:29:31.363]                 for (kk in seq_along(NAMES)) {
[01:29:31.363]                   name <- added[[kk]]
[01:29:31.363]                   NAME <- NAMES[[kk]]
[01:29:31.363]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.363]                     next
[01:29:31.363]                   args[[name]] <- ""
[01:29:31.363]                 }
[01:29:31.363]                 NAMES <- toupper(removed)
[01:29:31.363]                 for (kk in seq_along(NAMES)) {
[01:29:31.363]                   name <- removed[[kk]]
[01:29:31.363]                   NAME <- NAMES[[kk]]
[01:29:31.363]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.363]                     next
[01:29:31.363]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.363]                 }
[01:29:31.363]                 if (length(args) > 0) 
[01:29:31.363]                   base::do.call(base::Sys.setenv, args = args)
[01:29:31.363]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:31.363]             }
[01:29:31.363]             else {
[01:29:31.363]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:31.363]             }
[01:29:31.363]             {
[01:29:31.363]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:31.363]                   0L) {
[01:29:31.363]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:31.363]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:31.363]                   base::options(opts)
[01:29:31.363]                 }
[01:29:31.363]                 {
[01:29:31.363]                   {
[01:29:31.363]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:31.363]                     NULL
[01:29:31.363]                   }
[01:29:31.363]                   options(future.plan = NULL)
[01:29:31.363]                   if (is.na(NA_character_)) 
[01:29:31.363]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.363]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:31.363]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:31.363]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:31.363]                     envir = parent.frame()) 
[01:29:31.363]                   {
[01:29:31.363]                     if (is.function(workers)) 
[01:29:31.363]                       workers <- workers()
[01:29:31.363]                     workers <- structure(as.integer(workers), 
[01:29:31.363]                       class = class(workers))
[01:29:31.363]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:31.363]                       workers >= 1)
[01:29:31.363]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:31.363]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:31.363]                     }
[01:29:31.363]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:31.363]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:31.363]                       envir = envir)
[01:29:31.363]                     if (!future$lazy) 
[01:29:31.363]                       future <- run(future)
[01:29:31.363]                     invisible(future)
[01:29:31.363]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:31.363]                 }
[01:29:31.363]             }
[01:29:31.363]         }
[01:29:31.363]     })
[01:29:31.363]     if (TRUE) {
[01:29:31.363]         base::sink(type = "output", split = FALSE)
[01:29:31.363]         if (TRUE) {
[01:29:31.363]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:31.363]         }
[01:29:31.363]         else {
[01:29:31.363]             ...future.result["stdout"] <- base::list(NULL)
[01:29:31.363]         }
[01:29:31.363]         base::close(...future.stdout)
[01:29:31.363]         ...future.stdout <- NULL
[01:29:31.363]     }
[01:29:31.363]     ...future.result$conditions <- ...future.conditions
[01:29:31.363]     ...future.result$finished <- base::Sys.time()
[01:29:31.363]     ...future.result
[01:29:31.363] }
[01:29:31.368] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:31.369] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:31.369] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:31.369] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:31.370] MultisessionFuture started
[01:29:31.370] - Launch lazy future ... done
[01:29:31.370] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_1-99530'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96f75eba0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[01:29:31.388] receiveMessageFromWorker() for ClusterFuture ...
[01:29:31.388] - Validating connection of MultisessionFuture
[01:29:31.389] - received message: FutureResult
[01:29:31.389] - Received FutureResult
[01:29:31.389] - Erased future from FutureRegistry
[01:29:31.389] result() for ClusterFuture ...
[01:29:31.390] - result already collected: FutureResult
[01:29:31.390] result() for ClusterFuture ... done
[01:29:31.390] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.390] getGlobalsAndPackages() ...
[01:29:31.390] Searching for globals...
[01:29:31.392] - globals found: [3] '{', 'sample', 'x'
[01:29:31.392] Searching for globals ... DONE
[01:29:31.392] Resolving globals: FALSE
[01:29:31.393] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:31.393] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:31.393] - globals: [1] 'x'
[01:29:31.394] 
[01:29:31.394] getGlobalsAndPackages() ... DONE
[01:29:31.394] run() for 'Future' ...
[01:29:31.394] - state: 'created'
[01:29:31.395] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:31.409] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.410] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:31.410]   - Field: 'node'
[01:29:31.410]   - Field: 'label'
[01:29:31.410]   - Field: 'local'
[01:29:31.410]   - Field: 'owner'
[01:29:31.411]   - Field: 'envir'
[01:29:31.411]   - Field: 'workers'
[01:29:31.411]   - Field: 'packages'
[01:29:31.411]   - Field: 'gc'
[01:29:31.411]   - Field: 'conditions'
[01:29:31.411]   - Field: 'persistent'
[01:29:31.412]   - Field: 'expr'
[01:29:31.412]   - Field: 'uuid'
[01:29:31.412]   - Field: 'seed'
[01:29:31.412]   - Field: 'version'
[01:29:31.412]   - Field: 'result'
[01:29:31.412]   - Field: 'asynchronous'
[01:29:31.413]   - Field: 'calls'
[01:29:31.413]   - Field: 'globals'
[01:29:31.413]   - Field: 'stdout'
[01:29:31.413]   - Field: 'earlySignal'
[01:29:31.413]   - Field: 'lazy'
[01:29:31.414]   - Field: 'state'
[01:29:31.414] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:31.414] - Launch lazy future ...
[01:29:31.414] Packages needed by the future expression (n = 0): <none>
[01:29:31.414] Packages needed by future strategies (n = 0): <none>
[01:29:31.415] {
[01:29:31.415]     {
[01:29:31.415]         {
[01:29:31.415]             ...future.startTime <- base::Sys.time()
[01:29:31.415]             {
[01:29:31.415]                 {
[01:29:31.415]                   {
[01:29:31.415]                     {
[01:29:31.415]                       base::local({
[01:29:31.415]                         has_future <- base::requireNamespace("future", 
[01:29:31.415]                           quietly = TRUE)
[01:29:31.415]                         if (has_future) {
[01:29:31.415]                           ns <- base::getNamespace("future")
[01:29:31.415]                           version <- ns[[".package"]][["version"]]
[01:29:31.415]                           if (is.null(version)) 
[01:29:31.415]                             version <- utils::packageVersion("future")
[01:29:31.415]                         }
[01:29:31.415]                         else {
[01:29:31.415]                           version <- NULL
[01:29:31.415]                         }
[01:29:31.415]                         if (!has_future || version < "1.8.0") {
[01:29:31.415]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:31.415]                             "", base::R.version$version.string), 
[01:29:31.415]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:31.415]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:31.415]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:31.415]                               "release", "version")], collapse = " "), 
[01:29:31.415]                             hostname = base::Sys.info()[["nodename"]])
[01:29:31.415]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:31.415]                             info)
[01:29:31.415]                           info <- base::paste(info, collapse = "; ")
[01:29:31.415]                           if (!has_future) {
[01:29:31.415]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:31.415]                               info)
[01:29:31.415]                           }
[01:29:31.415]                           else {
[01:29:31.415]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:31.415]                               info, version)
[01:29:31.415]                           }
[01:29:31.415]                           base::stop(msg)
[01:29:31.415]                         }
[01:29:31.415]                       })
[01:29:31.415]                     }
[01:29:31.415]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:31.415]                     base::options(mc.cores = 1L)
[01:29:31.415]                   }
[01:29:31.415]                   options(future.plan = NULL)
[01:29:31.415]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.415]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:31.415]                 }
[01:29:31.415]                 ...future.workdir <- getwd()
[01:29:31.415]             }
[01:29:31.415]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:31.415]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:31.415]         }
[01:29:31.415]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:31.415]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:31.415]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:31.415]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:31.415]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:31.415]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:31.415]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:31.415]             base::names(...future.oldOptions))
[01:29:31.415]     }
[01:29:31.415]     if (FALSE) {
[01:29:31.415]     }
[01:29:31.415]     else {
[01:29:31.415]         if (TRUE) {
[01:29:31.415]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:31.415]                 open = "w")
[01:29:31.415]         }
[01:29:31.415]         else {
[01:29:31.415]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:31.415]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:31.415]         }
[01:29:31.415]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:31.415]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:31.415]             base::sink(type = "output", split = FALSE)
[01:29:31.415]             base::close(...future.stdout)
[01:29:31.415]         }, add = TRUE)
[01:29:31.415]     }
[01:29:31.415]     ...future.frame <- base::sys.nframe()
[01:29:31.415]     ...future.conditions <- base::list()
[01:29:31.415]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:31.415]     if (FALSE) {
[01:29:31.415]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:31.415]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:31.415]     }
[01:29:31.415]     ...future.result <- base::tryCatch({
[01:29:31.415]         base::withCallingHandlers({
[01:29:31.415]             ...future.value <- base::withVisible(base::local({
[01:29:31.415]                 ...future.makeSendCondition <- base::local({
[01:29:31.415]                   sendCondition <- NULL
[01:29:31.415]                   function(frame = 1L) {
[01:29:31.415]                     if (is.function(sendCondition)) 
[01:29:31.415]                       return(sendCondition)
[01:29:31.415]                     ns <- getNamespace("parallel")
[01:29:31.415]                     if (exists("sendData", mode = "function", 
[01:29:31.415]                       envir = ns)) {
[01:29:31.415]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:31.415]                         envir = ns)
[01:29:31.415]                       envir <- sys.frame(frame)
[01:29:31.415]                       master <- NULL
[01:29:31.415]                       while (!identical(envir, .GlobalEnv) && 
[01:29:31.415]                         !identical(envir, emptyenv())) {
[01:29:31.415]                         if (exists("master", mode = "list", envir = envir, 
[01:29:31.415]                           inherits = FALSE)) {
[01:29:31.415]                           master <- get("master", mode = "list", 
[01:29:31.415]                             envir = envir, inherits = FALSE)
[01:29:31.415]                           if (inherits(master, c("SOCKnode", 
[01:29:31.415]                             "SOCK0node"))) {
[01:29:31.415]                             sendCondition <<- function(cond) {
[01:29:31.415]                               data <- list(type = "VALUE", value = cond, 
[01:29:31.415]                                 success = TRUE)
[01:29:31.415]                               parallel_sendData(master, data)
[01:29:31.415]                             }
[01:29:31.415]                             return(sendCondition)
[01:29:31.415]                           }
[01:29:31.415]                         }
[01:29:31.415]                         frame <- frame + 1L
[01:29:31.415]                         envir <- sys.frame(frame)
[01:29:31.415]                       }
[01:29:31.415]                     }
[01:29:31.415]                     sendCondition <<- function(cond) NULL
[01:29:31.415]                   }
[01:29:31.415]                 })
[01:29:31.415]                 withCallingHandlers({
[01:29:31.415]                   {
[01:29:31.415]                     sample(x, size = 1L)
[01:29:31.415]                   }
[01:29:31.415]                 }, immediateCondition = function(cond) {
[01:29:31.415]                   sendCondition <- ...future.makeSendCondition()
[01:29:31.415]                   sendCondition(cond)
[01:29:31.415]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.415]                   {
[01:29:31.415]                     inherits <- base::inherits
[01:29:31.415]                     invokeRestart <- base::invokeRestart
[01:29:31.415]                     is.null <- base::is.null
[01:29:31.415]                     muffled <- FALSE
[01:29:31.415]                     if (inherits(cond, "message")) {
[01:29:31.415]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:31.415]                       if (muffled) 
[01:29:31.415]                         invokeRestart("muffleMessage")
[01:29:31.415]                     }
[01:29:31.415]                     else if (inherits(cond, "warning")) {
[01:29:31.415]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:31.415]                       if (muffled) 
[01:29:31.415]                         invokeRestart("muffleWarning")
[01:29:31.415]                     }
[01:29:31.415]                     else if (inherits(cond, "condition")) {
[01:29:31.415]                       if (!is.null(pattern)) {
[01:29:31.415]                         computeRestarts <- base::computeRestarts
[01:29:31.415]                         grepl <- base::grepl
[01:29:31.415]                         restarts <- computeRestarts(cond)
[01:29:31.415]                         for (restart in restarts) {
[01:29:31.415]                           name <- restart$name
[01:29:31.415]                           if (is.null(name)) 
[01:29:31.415]                             next
[01:29:31.415]                           if (!grepl(pattern, name)) 
[01:29:31.415]                             next
[01:29:31.415]                           invokeRestart(restart)
[01:29:31.415]                           muffled <- TRUE
[01:29:31.415]                           break
[01:29:31.415]                         }
[01:29:31.415]                       }
[01:29:31.415]                     }
[01:29:31.415]                     invisible(muffled)
[01:29:31.415]                   }
[01:29:31.415]                   muffleCondition(cond)
[01:29:31.415]                 })
[01:29:31.415]             }))
[01:29:31.415]             future::FutureResult(value = ...future.value$value, 
[01:29:31.415]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.415]                   ...future.rng), globalenv = if (FALSE) 
[01:29:31.415]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:31.415]                     ...future.globalenv.names))
[01:29:31.415]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:31.415]         }, condition = base::local({
[01:29:31.415]             c <- base::c
[01:29:31.415]             inherits <- base::inherits
[01:29:31.415]             invokeRestart <- base::invokeRestart
[01:29:31.415]             length <- base::length
[01:29:31.415]             list <- base::list
[01:29:31.415]             seq.int <- base::seq.int
[01:29:31.415]             signalCondition <- base::signalCondition
[01:29:31.415]             sys.calls <- base::sys.calls
[01:29:31.415]             `[[` <- base::`[[`
[01:29:31.415]             `+` <- base::`+`
[01:29:31.415]             `<<-` <- base::`<<-`
[01:29:31.415]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:31.415]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:31.415]                   3L)]
[01:29:31.415]             }
[01:29:31.415]             function(cond) {
[01:29:31.415]                 is_error <- inherits(cond, "error")
[01:29:31.415]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:31.415]                   NULL)
[01:29:31.415]                 if (is_error) {
[01:29:31.415]                   sessionInformation <- function() {
[01:29:31.415]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:31.415]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:31.415]                       search = base::search(), system = base::Sys.info())
[01:29:31.415]                   }
[01:29:31.415]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.415]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:31.415]                     cond$call), session = sessionInformation(), 
[01:29:31.415]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:31.415]                   signalCondition(cond)
[01:29:31.415]                 }
[01:29:31.415]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:31.415]                 "immediateCondition"))) {
[01:29:31.415]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:31.415]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.415]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:31.415]                   if (TRUE && !signal) {
[01:29:31.415]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.415]                     {
[01:29:31.415]                       inherits <- base::inherits
[01:29:31.415]                       invokeRestart <- base::invokeRestart
[01:29:31.415]                       is.null <- base::is.null
[01:29:31.415]                       muffled <- FALSE
[01:29:31.415]                       if (inherits(cond, "message")) {
[01:29:31.415]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.415]                         if (muffled) 
[01:29:31.415]                           invokeRestart("muffleMessage")
[01:29:31.415]                       }
[01:29:31.415]                       else if (inherits(cond, "warning")) {
[01:29:31.415]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.415]                         if (muffled) 
[01:29:31.415]                           invokeRestart("muffleWarning")
[01:29:31.415]                       }
[01:29:31.415]                       else if (inherits(cond, "condition")) {
[01:29:31.415]                         if (!is.null(pattern)) {
[01:29:31.415]                           computeRestarts <- base::computeRestarts
[01:29:31.415]                           grepl <- base::grepl
[01:29:31.415]                           restarts <- computeRestarts(cond)
[01:29:31.415]                           for (restart in restarts) {
[01:29:31.415]                             name <- restart$name
[01:29:31.415]                             if (is.null(name)) 
[01:29:31.415]                               next
[01:29:31.415]                             if (!grepl(pattern, name)) 
[01:29:31.415]                               next
[01:29:31.415]                             invokeRestart(restart)
[01:29:31.415]                             muffled <- TRUE
[01:29:31.415]                             break
[01:29:31.415]                           }
[01:29:31.415]                         }
[01:29:31.415]                       }
[01:29:31.415]                       invisible(muffled)
[01:29:31.415]                     }
[01:29:31.415]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.415]                   }
[01:29:31.415]                 }
[01:29:31.415]                 else {
[01:29:31.415]                   if (TRUE) {
[01:29:31.415]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.415]                     {
[01:29:31.415]                       inherits <- base::inherits
[01:29:31.415]                       invokeRestart <- base::invokeRestart
[01:29:31.415]                       is.null <- base::is.null
[01:29:31.415]                       muffled <- FALSE
[01:29:31.415]                       if (inherits(cond, "message")) {
[01:29:31.415]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.415]                         if (muffled) 
[01:29:31.415]                           invokeRestart("muffleMessage")
[01:29:31.415]                       }
[01:29:31.415]                       else if (inherits(cond, "warning")) {
[01:29:31.415]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.415]                         if (muffled) 
[01:29:31.415]                           invokeRestart("muffleWarning")
[01:29:31.415]                       }
[01:29:31.415]                       else if (inherits(cond, "condition")) {
[01:29:31.415]                         if (!is.null(pattern)) {
[01:29:31.415]                           computeRestarts <- base::computeRestarts
[01:29:31.415]                           grepl <- base::grepl
[01:29:31.415]                           restarts <- computeRestarts(cond)
[01:29:31.415]                           for (restart in restarts) {
[01:29:31.415]                             name <- restart$name
[01:29:31.415]                             if (is.null(name)) 
[01:29:31.415]                               next
[01:29:31.415]                             if (!grepl(pattern, name)) 
[01:29:31.415]                               next
[01:29:31.415]                             invokeRestart(restart)
[01:29:31.415]                             muffled <- TRUE
[01:29:31.415]                             break
[01:29:31.415]                           }
[01:29:31.415]                         }
[01:29:31.415]                       }
[01:29:31.415]                       invisible(muffled)
[01:29:31.415]                     }
[01:29:31.415]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.415]                   }
[01:29:31.415]                 }
[01:29:31.415]             }
[01:29:31.415]         }))
[01:29:31.415]     }, error = function(ex) {
[01:29:31.415]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:31.415]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.415]                 ...future.rng), started = ...future.startTime, 
[01:29:31.415]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:31.415]             version = "1.8"), class = "FutureResult")
[01:29:31.415]     }, finally = {
[01:29:31.415]         if (!identical(...future.workdir, getwd())) 
[01:29:31.415]             setwd(...future.workdir)
[01:29:31.415]         {
[01:29:31.415]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:31.415]                 ...future.oldOptions$nwarnings <- NULL
[01:29:31.415]             }
[01:29:31.415]             base::options(...future.oldOptions)
[01:29:31.415]             if (.Platform$OS.type == "windows") {
[01:29:31.415]                 old_names <- names(...future.oldEnvVars)
[01:29:31.415]                 envs <- base::Sys.getenv()
[01:29:31.415]                 names <- names(envs)
[01:29:31.415]                 common <- intersect(names, old_names)
[01:29:31.415]                 added <- setdiff(names, old_names)
[01:29:31.415]                 removed <- setdiff(old_names, names)
[01:29:31.415]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:31.415]                   envs[common]]
[01:29:31.415]                 NAMES <- toupper(changed)
[01:29:31.415]                 args <- list()
[01:29:31.415]                 for (kk in seq_along(NAMES)) {
[01:29:31.415]                   name <- changed[[kk]]
[01:29:31.415]                   NAME <- NAMES[[kk]]
[01:29:31.415]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.415]                     next
[01:29:31.415]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.415]                 }
[01:29:31.415]                 NAMES <- toupper(added)
[01:29:31.415]                 for (kk in seq_along(NAMES)) {
[01:29:31.415]                   name <- added[[kk]]
[01:29:31.415]                   NAME <- NAMES[[kk]]
[01:29:31.415]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.415]                     next
[01:29:31.415]                   args[[name]] <- ""
[01:29:31.415]                 }
[01:29:31.415]                 NAMES <- toupper(removed)
[01:29:31.415]                 for (kk in seq_along(NAMES)) {
[01:29:31.415]                   name <- removed[[kk]]
[01:29:31.415]                   NAME <- NAMES[[kk]]
[01:29:31.415]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.415]                     next
[01:29:31.415]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.415]                 }
[01:29:31.415]                 if (length(args) > 0) 
[01:29:31.415]                   base::do.call(base::Sys.setenv, args = args)
[01:29:31.415]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:31.415]             }
[01:29:31.415]             else {
[01:29:31.415]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:31.415]             }
[01:29:31.415]             {
[01:29:31.415]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:31.415]                   0L) {
[01:29:31.415]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:31.415]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:31.415]                   base::options(opts)
[01:29:31.415]                 }
[01:29:31.415]                 {
[01:29:31.415]                   {
[01:29:31.415]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:31.415]                     NULL
[01:29:31.415]                   }
[01:29:31.415]                   options(future.plan = NULL)
[01:29:31.415]                   if (is.na(NA_character_)) 
[01:29:31.415]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.415]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:31.415]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:31.415]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:31.415]                     envir = parent.frame()) 
[01:29:31.415]                   {
[01:29:31.415]                     if (is.function(workers)) 
[01:29:31.415]                       workers <- workers()
[01:29:31.415]                     workers <- structure(as.integer(workers), 
[01:29:31.415]                       class = class(workers))
[01:29:31.415]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:31.415]                       workers >= 1)
[01:29:31.415]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:31.415]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:31.415]                     }
[01:29:31.415]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:31.415]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:31.415]                       envir = envir)
[01:29:31.415]                     if (!future$lazy) 
[01:29:31.415]                       future <- run(future)
[01:29:31.415]                     invisible(future)
[01:29:31.415]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:31.415]                 }
[01:29:31.415]             }
[01:29:31.415]         }
[01:29:31.415]     })
[01:29:31.415]     if (TRUE) {
[01:29:31.415]         base::sink(type = "output", split = FALSE)
[01:29:31.415]         if (TRUE) {
[01:29:31.415]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:31.415]         }
[01:29:31.415]         else {
[01:29:31.415]             ...future.result["stdout"] <- base::list(NULL)
[01:29:31.415]         }
[01:29:31.415]         base::close(...future.stdout)
[01:29:31.415]         ...future.stdout <- NULL
[01:29:31.415]     }
[01:29:31.415]     ...future.result$conditions <- ...future.conditions
[01:29:31.415]     ...future.result$finished <- base::Sys.time()
[01:29:31.415]     ...future.result
[01:29:31.415] }
[01:29:31.420] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:31.421] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:31.421] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:31.421] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:31.426] MultisessionFuture started
[01:29:31.426] - Launch lazy future ... done
[01:29:31.426] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_2-814460'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96f75eba0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[01:29:31.490] receiveMessageFromWorker() for ClusterFuture ...
[01:29:31.491] - Validating connection of MultisessionFuture
[01:29:31.491] - received message: FutureResult
[01:29:31.491] - Received FutureResult
[01:29:31.491] - Erased future from FutureRegistry
[01:29:31.491] result() for ClusterFuture ...
[01:29:31.492] - result already collected: FutureResult
[01:29:31.492] result() for ClusterFuture ... done
[01:29:31.492] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.492] getGlobalsAndPackages() ...
[01:29:31.492] Searching for globals...
[01:29:31.494] - globals found: [3] '{', 'sample', 'x'
[01:29:31.494] Searching for globals ... DONE
[01:29:31.494] Resolving globals: FALSE
[01:29:31.494] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:31.495] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:31.495] - globals: [1] 'x'
[01:29:31.495] 
[01:29:31.495] getGlobalsAndPackages() ... DONE
[01:29:31.496] run() for 'Future' ...
[01:29:31.496] - state: 'created'
[01:29:31.496] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:31.511] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.511] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:31.511]   - Field: 'node'
[01:29:31.511]   - Field: 'label'
[01:29:31.511]   - Field: 'local'
[01:29:31.512]   - Field: 'owner'
[01:29:31.512]   - Field: 'envir'
[01:29:31.512]   - Field: 'workers'
[01:29:31.512]   - Field: 'packages'
[01:29:31.512]   - Field: 'gc'
[01:29:31.513]   - Field: 'conditions'
[01:29:31.513]   - Field: 'persistent'
[01:29:31.513]   - Field: 'expr'
[01:29:31.513]   - Field: 'uuid'
[01:29:31.513]   - Field: 'seed'
[01:29:31.513]   - Field: 'version'
[01:29:31.514]   - Field: 'result'
[01:29:31.514]   - Field: 'asynchronous'
[01:29:31.514]   - Field: 'calls'
[01:29:31.514]   - Field: 'globals'
[01:29:31.514]   - Field: 'stdout'
[01:29:31.514]   - Field: 'earlySignal'
[01:29:31.515]   - Field: 'lazy'
[01:29:31.515]   - Field: 'state'
[01:29:31.515] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:31.515] - Launch lazy future ...
[01:29:31.516] Packages needed by the future expression (n = 0): <none>
[01:29:31.516] Packages needed by future strategies (n = 0): <none>
[01:29:31.516] {
[01:29:31.516]     {
[01:29:31.516]         {
[01:29:31.516]             ...future.startTime <- base::Sys.time()
[01:29:31.516]             {
[01:29:31.516]                 {
[01:29:31.516]                   {
[01:29:31.516]                     {
[01:29:31.516]                       base::local({
[01:29:31.516]                         has_future <- base::requireNamespace("future", 
[01:29:31.516]                           quietly = TRUE)
[01:29:31.516]                         if (has_future) {
[01:29:31.516]                           ns <- base::getNamespace("future")
[01:29:31.516]                           version <- ns[[".package"]][["version"]]
[01:29:31.516]                           if (is.null(version)) 
[01:29:31.516]                             version <- utils::packageVersion("future")
[01:29:31.516]                         }
[01:29:31.516]                         else {
[01:29:31.516]                           version <- NULL
[01:29:31.516]                         }
[01:29:31.516]                         if (!has_future || version < "1.8.0") {
[01:29:31.516]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:31.516]                             "", base::R.version$version.string), 
[01:29:31.516]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:31.516]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:31.516]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:31.516]                               "release", "version")], collapse = " "), 
[01:29:31.516]                             hostname = base::Sys.info()[["nodename"]])
[01:29:31.516]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:31.516]                             info)
[01:29:31.516]                           info <- base::paste(info, collapse = "; ")
[01:29:31.516]                           if (!has_future) {
[01:29:31.516]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:31.516]                               info)
[01:29:31.516]                           }
[01:29:31.516]                           else {
[01:29:31.516]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:31.516]                               info, version)
[01:29:31.516]                           }
[01:29:31.516]                           base::stop(msg)
[01:29:31.516]                         }
[01:29:31.516]                       })
[01:29:31.516]                     }
[01:29:31.516]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:31.516]                     base::options(mc.cores = 1L)
[01:29:31.516]                   }
[01:29:31.516]                   options(future.plan = NULL)
[01:29:31.516]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.516]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:31.516]                 }
[01:29:31.516]                 ...future.workdir <- getwd()
[01:29:31.516]             }
[01:29:31.516]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:31.516]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:31.516]         }
[01:29:31.516]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:31.516]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:31.516]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:31.516]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:31.516]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:31.516]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:31.516]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:31.516]             base::names(...future.oldOptions))
[01:29:31.516]     }
[01:29:31.516]     if (FALSE) {
[01:29:31.516]     }
[01:29:31.516]     else {
[01:29:31.516]         if (TRUE) {
[01:29:31.516]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:31.516]                 open = "w")
[01:29:31.516]         }
[01:29:31.516]         else {
[01:29:31.516]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:31.516]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:31.516]         }
[01:29:31.516]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:31.516]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:31.516]             base::sink(type = "output", split = FALSE)
[01:29:31.516]             base::close(...future.stdout)
[01:29:31.516]         }, add = TRUE)
[01:29:31.516]     }
[01:29:31.516]     ...future.frame <- base::sys.nframe()
[01:29:31.516]     ...future.conditions <- base::list()
[01:29:31.516]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:31.516]     if (FALSE) {
[01:29:31.516]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:31.516]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:31.516]     }
[01:29:31.516]     ...future.result <- base::tryCatch({
[01:29:31.516]         base::withCallingHandlers({
[01:29:31.516]             ...future.value <- base::withVisible(base::local({
[01:29:31.516]                 ...future.makeSendCondition <- base::local({
[01:29:31.516]                   sendCondition <- NULL
[01:29:31.516]                   function(frame = 1L) {
[01:29:31.516]                     if (is.function(sendCondition)) 
[01:29:31.516]                       return(sendCondition)
[01:29:31.516]                     ns <- getNamespace("parallel")
[01:29:31.516]                     if (exists("sendData", mode = "function", 
[01:29:31.516]                       envir = ns)) {
[01:29:31.516]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:31.516]                         envir = ns)
[01:29:31.516]                       envir <- sys.frame(frame)
[01:29:31.516]                       master <- NULL
[01:29:31.516]                       while (!identical(envir, .GlobalEnv) && 
[01:29:31.516]                         !identical(envir, emptyenv())) {
[01:29:31.516]                         if (exists("master", mode = "list", envir = envir, 
[01:29:31.516]                           inherits = FALSE)) {
[01:29:31.516]                           master <- get("master", mode = "list", 
[01:29:31.516]                             envir = envir, inherits = FALSE)
[01:29:31.516]                           if (inherits(master, c("SOCKnode", 
[01:29:31.516]                             "SOCK0node"))) {
[01:29:31.516]                             sendCondition <<- function(cond) {
[01:29:31.516]                               data <- list(type = "VALUE", value = cond, 
[01:29:31.516]                                 success = TRUE)
[01:29:31.516]                               parallel_sendData(master, data)
[01:29:31.516]                             }
[01:29:31.516]                             return(sendCondition)
[01:29:31.516]                           }
[01:29:31.516]                         }
[01:29:31.516]                         frame <- frame + 1L
[01:29:31.516]                         envir <- sys.frame(frame)
[01:29:31.516]                       }
[01:29:31.516]                     }
[01:29:31.516]                     sendCondition <<- function(cond) NULL
[01:29:31.516]                   }
[01:29:31.516]                 })
[01:29:31.516]                 withCallingHandlers({
[01:29:31.516]                   {
[01:29:31.516]                     sample(x, size = 1L)
[01:29:31.516]                   }
[01:29:31.516]                 }, immediateCondition = function(cond) {
[01:29:31.516]                   sendCondition <- ...future.makeSendCondition()
[01:29:31.516]                   sendCondition(cond)
[01:29:31.516]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.516]                   {
[01:29:31.516]                     inherits <- base::inherits
[01:29:31.516]                     invokeRestart <- base::invokeRestart
[01:29:31.516]                     is.null <- base::is.null
[01:29:31.516]                     muffled <- FALSE
[01:29:31.516]                     if (inherits(cond, "message")) {
[01:29:31.516]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:31.516]                       if (muffled) 
[01:29:31.516]                         invokeRestart("muffleMessage")
[01:29:31.516]                     }
[01:29:31.516]                     else if (inherits(cond, "warning")) {
[01:29:31.516]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:31.516]                       if (muffled) 
[01:29:31.516]                         invokeRestart("muffleWarning")
[01:29:31.516]                     }
[01:29:31.516]                     else if (inherits(cond, "condition")) {
[01:29:31.516]                       if (!is.null(pattern)) {
[01:29:31.516]                         computeRestarts <- base::computeRestarts
[01:29:31.516]                         grepl <- base::grepl
[01:29:31.516]                         restarts <- computeRestarts(cond)
[01:29:31.516]                         for (restart in restarts) {
[01:29:31.516]                           name <- restart$name
[01:29:31.516]                           if (is.null(name)) 
[01:29:31.516]                             next
[01:29:31.516]                           if (!grepl(pattern, name)) 
[01:29:31.516]                             next
[01:29:31.516]                           invokeRestart(restart)
[01:29:31.516]                           muffled <- TRUE
[01:29:31.516]                           break
[01:29:31.516]                         }
[01:29:31.516]                       }
[01:29:31.516]                     }
[01:29:31.516]                     invisible(muffled)
[01:29:31.516]                   }
[01:29:31.516]                   muffleCondition(cond)
[01:29:31.516]                 })
[01:29:31.516]             }))
[01:29:31.516]             future::FutureResult(value = ...future.value$value, 
[01:29:31.516]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.516]                   ...future.rng), globalenv = if (FALSE) 
[01:29:31.516]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:31.516]                     ...future.globalenv.names))
[01:29:31.516]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:31.516]         }, condition = base::local({
[01:29:31.516]             c <- base::c
[01:29:31.516]             inherits <- base::inherits
[01:29:31.516]             invokeRestart <- base::invokeRestart
[01:29:31.516]             length <- base::length
[01:29:31.516]             list <- base::list
[01:29:31.516]             seq.int <- base::seq.int
[01:29:31.516]             signalCondition <- base::signalCondition
[01:29:31.516]             sys.calls <- base::sys.calls
[01:29:31.516]             `[[` <- base::`[[`
[01:29:31.516]             `+` <- base::`+`
[01:29:31.516]             `<<-` <- base::`<<-`
[01:29:31.516]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:31.516]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:31.516]                   3L)]
[01:29:31.516]             }
[01:29:31.516]             function(cond) {
[01:29:31.516]                 is_error <- inherits(cond, "error")
[01:29:31.516]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:31.516]                   NULL)
[01:29:31.516]                 if (is_error) {
[01:29:31.516]                   sessionInformation <- function() {
[01:29:31.516]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:31.516]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:31.516]                       search = base::search(), system = base::Sys.info())
[01:29:31.516]                   }
[01:29:31.516]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.516]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:31.516]                     cond$call), session = sessionInformation(), 
[01:29:31.516]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:31.516]                   signalCondition(cond)
[01:29:31.516]                 }
[01:29:31.516]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:31.516]                 "immediateCondition"))) {
[01:29:31.516]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:31.516]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.516]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:31.516]                   if (TRUE && !signal) {
[01:29:31.516]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.516]                     {
[01:29:31.516]                       inherits <- base::inherits
[01:29:31.516]                       invokeRestart <- base::invokeRestart
[01:29:31.516]                       is.null <- base::is.null
[01:29:31.516]                       muffled <- FALSE
[01:29:31.516]                       if (inherits(cond, "message")) {
[01:29:31.516]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.516]                         if (muffled) 
[01:29:31.516]                           invokeRestart("muffleMessage")
[01:29:31.516]                       }
[01:29:31.516]                       else if (inherits(cond, "warning")) {
[01:29:31.516]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.516]                         if (muffled) 
[01:29:31.516]                           invokeRestart("muffleWarning")
[01:29:31.516]                       }
[01:29:31.516]                       else if (inherits(cond, "condition")) {
[01:29:31.516]                         if (!is.null(pattern)) {
[01:29:31.516]                           computeRestarts <- base::computeRestarts
[01:29:31.516]                           grepl <- base::grepl
[01:29:31.516]                           restarts <- computeRestarts(cond)
[01:29:31.516]                           for (restart in restarts) {
[01:29:31.516]                             name <- restart$name
[01:29:31.516]                             if (is.null(name)) 
[01:29:31.516]                               next
[01:29:31.516]                             if (!grepl(pattern, name)) 
[01:29:31.516]                               next
[01:29:31.516]                             invokeRestart(restart)
[01:29:31.516]                             muffled <- TRUE
[01:29:31.516]                             break
[01:29:31.516]                           }
[01:29:31.516]                         }
[01:29:31.516]                       }
[01:29:31.516]                       invisible(muffled)
[01:29:31.516]                     }
[01:29:31.516]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.516]                   }
[01:29:31.516]                 }
[01:29:31.516]                 else {
[01:29:31.516]                   if (TRUE) {
[01:29:31.516]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.516]                     {
[01:29:31.516]                       inherits <- base::inherits
[01:29:31.516]                       invokeRestart <- base::invokeRestart
[01:29:31.516]                       is.null <- base::is.null
[01:29:31.516]                       muffled <- FALSE
[01:29:31.516]                       if (inherits(cond, "message")) {
[01:29:31.516]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.516]                         if (muffled) 
[01:29:31.516]                           invokeRestart("muffleMessage")
[01:29:31.516]                       }
[01:29:31.516]                       else if (inherits(cond, "warning")) {
[01:29:31.516]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.516]                         if (muffled) 
[01:29:31.516]                           invokeRestart("muffleWarning")
[01:29:31.516]                       }
[01:29:31.516]                       else if (inherits(cond, "condition")) {
[01:29:31.516]                         if (!is.null(pattern)) {
[01:29:31.516]                           computeRestarts <- base::computeRestarts
[01:29:31.516]                           grepl <- base::grepl
[01:29:31.516]                           restarts <- computeRestarts(cond)
[01:29:31.516]                           for (restart in restarts) {
[01:29:31.516]                             name <- restart$name
[01:29:31.516]                             if (is.null(name)) 
[01:29:31.516]                               next
[01:29:31.516]                             if (!grepl(pattern, name)) 
[01:29:31.516]                               next
[01:29:31.516]                             invokeRestart(restart)
[01:29:31.516]                             muffled <- TRUE
[01:29:31.516]                             break
[01:29:31.516]                           }
[01:29:31.516]                         }
[01:29:31.516]                       }
[01:29:31.516]                       invisible(muffled)
[01:29:31.516]                     }
[01:29:31.516]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.516]                   }
[01:29:31.516]                 }
[01:29:31.516]             }
[01:29:31.516]         }))
[01:29:31.516]     }, error = function(ex) {
[01:29:31.516]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:31.516]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.516]                 ...future.rng), started = ...future.startTime, 
[01:29:31.516]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:31.516]             version = "1.8"), class = "FutureResult")
[01:29:31.516]     }, finally = {
[01:29:31.516]         if (!identical(...future.workdir, getwd())) 
[01:29:31.516]             setwd(...future.workdir)
[01:29:31.516]         {
[01:29:31.516]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:31.516]                 ...future.oldOptions$nwarnings <- NULL
[01:29:31.516]             }
[01:29:31.516]             base::options(...future.oldOptions)
[01:29:31.516]             if (.Platform$OS.type == "windows") {
[01:29:31.516]                 old_names <- names(...future.oldEnvVars)
[01:29:31.516]                 envs <- base::Sys.getenv()
[01:29:31.516]                 names <- names(envs)
[01:29:31.516]                 common <- intersect(names, old_names)
[01:29:31.516]                 added <- setdiff(names, old_names)
[01:29:31.516]                 removed <- setdiff(old_names, names)
[01:29:31.516]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:31.516]                   envs[common]]
[01:29:31.516]                 NAMES <- toupper(changed)
[01:29:31.516]                 args <- list()
[01:29:31.516]                 for (kk in seq_along(NAMES)) {
[01:29:31.516]                   name <- changed[[kk]]
[01:29:31.516]                   NAME <- NAMES[[kk]]
[01:29:31.516]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.516]                     next
[01:29:31.516]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.516]                 }
[01:29:31.516]                 NAMES <- toupper(added)
[01:29:31.516]                 for (kk in seq_along(NAMES)) {
[01:29:31.516]                   name <- added[[kk]]
[01:29:31.516]                   NAME <- NAMES[[kk]]
[01:29:31.516]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.516]                     next
[01:29:31.516]                   args[[name]] <- ""
[01:29:31.516]                 }
[01:29:31.516]                 NAMES <- toupper(removed)
[01:29:31.516]                 for (kk in seq_along(NAMES)) {
[01:29:31.516]                   name <- removed[[kk]]
[01:29:31.516]                   NAME <- NAMES[[kk]]
[01:29:31.516]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.516]                     next
[01:29:31.516]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.516]                 }
[01:29:31.516]                 if (length(args) > 0) 
[01:29:31.516]                   base::do.call(base::Sys.setenv, args = args)
[01:29:31.516]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:31.516]             }
[01:29:31.516]             else {
[01:29:31.516]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:31.516]             }
[01:29:31.516]             {
[01:29:31.516]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:31.516]                   0L) {
[01:29:31.516]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:31.516]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:31.516]                   base::options(opts)
[01:29:31.516]                 }
[01:29:31.516]                 {
[01:29:31.516]                   {
[01:29:31.516]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:31.516]                     NULL
[01:29:31.516]                   }
[01:29:31.516]                   options(future.plan = NULL)
[01:29:31.516]                   if (is.na(NA_character_)) 
[01:29:31.516]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.516]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:31.516]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:31.516]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:31.516]                     envir = parent.frame()) 
[01:29:31.516]                   {
[01:29:31.516]                     if (is.function(workers)) 
[01:29:31.516]                       workers <- workers()
[01:29:31.516]                     workers <- structure(as.integer(workers), 
[01:29:31.516]                       class = class(workers))
[01:29:31.516]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:31.516]                       workers >= 1)
[01:29:31.516]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:31.516]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:31.516]                     }
[01:29:31.516]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:31.516]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:31.516]                       envir = envir)
[01:29:31.516]                     if (!future$lazy) 
[01:29:31.516]                       future <- run(future)
[01:29:31.516]                     invisible(future)
[01:29:31.516]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:31.516]                 }
[01:29:31.516]             }
[01:29:31.516]         }
[01:29:31.516]     })
[01:29:31.516]     if (TRUE) {
[01:29:31.516]         base::sink(type = "output", split = FALSE)
[01:29:31.516]         if (TRUE) {
[01:29:31.516]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:31.516]         }
[01:29:31.516]         else {
[01:29:31.516]             ...future.result["stdout"] <- base::list(NULL)
[01:29:31.516]         }
[01:29:31.516]         base::close(...future.stdout)
[01:29:31.516]         ...future.stdout <- NULL
[01:29:31.516]     }
[01:29:31.516]     ...future.result$conditions <- ...future.conditions
[01:29:31.516]     ...future.result$finished <- base::Sys.time()
[01:29:31.516]     ...future.result
[01:29:31.516] }
[01:29:31.522] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:31.522] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:31.523] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:31.523] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:31.524] MultisessionFuture started
[01:29:31.524] - Launch lazy future ... done
[01:29:31.524] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_3-263190'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96f75eba0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[01:29:31.542] receiveMessageFromWorker() for ClusterFuture ...
[01:29:31.542] - Validating connection of MultisessionFuture
[01:29:31.542] - received message: FutureResult
[01:29:31.542] - Received FutureResult
[01:29:31.543] - Erased future from FutureRegistry
[01:29:31.543] result() for ClusterFuture ...
[01:29:31.543] - result already collected: FutureResult
[01:29:31.543] result() for ClusterFuture ... done
[01:29:31.543] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.544] getGlobalsAndPackages() ...
[01:29:31.544] Searching for globals...
[01:29:31.545] - globals found: [3] '{', 'sample', 'x'
[01:29:31.545] Searching for globals ... DONE
[01:29:31.545] Resolving globals: FALSE
[01:29:31.546] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:31.546] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:31.547] - globals: [1] 'x'
[01:29:31.547] 
[01:29:31.547] getGlobalsAndPackages() ... DONE
[01:29:31.547] run() for 'Future' ...
[01:29:31.547] - state: 'created'
[01:29:31.548] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:31.563] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.563] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:31.563]   - Field: 'node'
[01:29:31.564]   - Field: 'label'
[01:29:31.564]   - Field: 'local'
[01:29:31.564]   - Field: 'owner'
[01:29:31.564]   - Field: 'envir'
[01:29:31.564]   - Field: 'workers'
[01:29:31.565]   - Field: 'packages'
[01:29:31.565]   - Field: 'gc'
[01:29:31.565]   - Field: 'conditions'
[01:29:31.565]   - Field: 'persistent'
[01:29:31.565]   - Field: 'expr'
[01:29:31.566]   - Field: 'uuid'
[01:29:31.566]   - Field: 'seed'
[01:29:31.566]   - Field: 'version'
[01:29:31.566]   - Field: 'result'
[01:29:31.566]   - Field: 'asynchronous'
[01:29:31.566]   - Field: 'calls'
[01:29:31.567]   - Field: 'globals'
[01:29:31.567]   - Field: 'stdout'
[01:29:31.567]   - Field: 'earlySignal'
[01:29:31.567]   - Field: 'lazy'
[01:29:31.567]   - Field: 'state'
[01:29:31.568] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:31.568] - Launch lazy future ...
[01:29:31.568] Packages needed by the future expression (n = 0): <none>
[01:29:31.568] Packages needed by future strategies (n = 0): <none>
[01:29:31.569] {
[01:29:31.569]     {
[01:29:31.569]         {
[01:29:31.569]             ...future.startTime <- base::Sys.time()
[01:29:31.569]             {
[01:29:31.569]                 {
[01:29:31.569]                   {
[01:29:31.569]                     {
[01:29:31.569]                       base::local({
[01:29:31.569]                         has_future <- base::requireNamespace("future", 
[01:29:31.569]                           quietly = TRUE)
[01:29:31.569]                         if (has_future) {
[01:29:31.569]                           ns <- base::getNamespace("future")
[01:29:31.569]                           version <- ns[[".package"]][["version"]]
[01:29:31.569]                           if (is.null(version)) 
[01:29:31.569]                             version <- utils::packageVersion("future")
[01:29:31.569]                         }
[01:29:31.569]                         else {
[01:29:31.569]                           version <- NULL
[01:29:31.569]                         }
[01:29:31.569]                         if (!has_future || version < "1.8.0") {
[01:29:31.569]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:31.569]                             "", base::R.version$version.string), 
[01:29:31.569]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:31.569]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:31.569]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:31.569]                               "release", "version")], collapse = " "), 
[01:29:31.569]                             hostname = base::Sys.info()[["nodename"]])
[01:29:31.569]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:31.569]                             info)
[01:29:31.569]                           info <- base::paste(info, collapse = "; ")
[01:29:31.569]                           if (!has_future) {
[01:29:31.569]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:31.569]                               info)
[01:29:31.569]                           }
[01:29:31.569]                           else {
[01:29:31.569]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:31.569]                               info, version)
[01:29:31.569]                           }
[01:29:31.569]                           base::stop(msg)
[01:29:31.569]                         }
[01:29:31.569]                       })
[01:29:31.569]                     }
[01:29:31.569]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:31.569]                     base::options(mc.cores = 1L)
[01:29:31.569]                   }
[01:29:31.569]                   options(future.plan = NULL)
[01:29:31.569]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.569]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:31.569]                 }
[01:29:31.569]                 ...future.workdir <- getwd()
[01:29:31.569]             }
[01:29:31.569]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:31.569]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:31.569]         }
[01:29:31.569]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:31.569]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:31.569]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:31.569]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:31.569]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:31.569]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:31.569]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:31.569]             base::names(...future.oldOptions))
[01:29:31.569]     }
[01:29:31.569]     if (FALSE) {
[01:29:31.569]     }
[01:29:31.569]     else {
[01:29:31.569]         if (TRUE) {
[01:29:31.569]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:31.569]                 open = "w")
[01:29:31.569]         }
[01:29:31.569]         else {
[01:29:31.569]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:31.569]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:31.569]         }
[01:29:31.569]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:31.569]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:31.569]             base::sink(type = "output", split = FALSE)
[01:29:31.569]             base::close(...future.stdout)
[01:29:31.569]         }, add = TRUE)
[01:29:31.569]     }
[01:29:31.569]     ...future.frame <- base::sys.nframe()
[01:29:31.569]     ...future.conditions <- base::list()
[01:29:31.569]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:31.569]     if (FALSE) {
[01:29:31.569]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:31.569]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:31.569]     }
[01:29:31.569]     ...future.result <- base::tryCatch({
[01:29:31.569]         base::withCallingHandlers({
[01:29:31.569]             ...future.value <- base::withVisible(base::local({
[01:29:31.569]                 ...future.makeSendCondition <- base::local({
[01:29:31.569]                   sendCondition <- NULL
[01:29:31.569]                   function(frame = 1L) {
[01:29:31.569]                     if (is.function(sendCondition)) 
[01:29:31.569]                       return(sendCondition)
[01:29:31.569]                     ns <- getNamespace("parallel")
[01:29:31.569]                     if (exists("sendData", mode = "function", 
[01:29:31.569]                       envir = ns)) {
[01:29:31.569]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:31.569]                         envir = ns)
[01:29:31.569]                       envir <- sys.frame(frame)
[01:29:31.569]                       master <- NULL
[01:29:31.569]                       while (!identical(envir, .GlobalEnv) && 
[01:29:31.569]                         !identical(envir, emptyenv())) {
[01:29:31.569]                         if (exists("master", mode = "list", envir = envir, 
[01:29:31.569]                           inherits = FALSE)) {
[01:29:31.569]                           master <- get("master", mode = "list", 
[01:29:31.569]                             envir = envir, inherits = FALSE)
[01:29:31.569]                           if (inherits(master, c("SOCKnode", 
[01:29:31.569]                             "SOCK0node"))) {
[01:29:31.569]                             sendCondition <<- function(cond) {
[01:29:31.569]                               data <- list(type = "VALUE", value = cond, 
[01:29:31.569]                                 success = TRUE)
[01:29:31.569]                               parallel_sendData(master, data)
[01:29:31.569]                             }
[01:29:31.569]                             return(sendCondition)
[01:29:31.569]                           }
[01:29:31.569]                         }
[01:29:31.569]                         frame <- frame + 1L
[01:29:31.569]                         envir <- sys.frame(frame)
[01:29:31.569]                       }
[01:29:31.569]                     }
[01:29:31.569]                     sendCondition <<- function(cond) NULL
[01:29:31.569]                   }
[01:29:31.569]                 })
[01:29:31.569]                 withCallingHandlers({
[01:29:31.569]                   {
[01:29:31.569]                     sample(x, size = 1L)
[01:29:31.569]                   }
[01:29:31.569]                 }, immediateCondition = function(cond) {
[01:29:31.569]                   sendCondition <- ...future.makeSendCondition()
[01:29:31.569]                   sendCondition(cond)
[01:29:31.569]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.569]                   {
[01:29:31.569]                     inherits <- base::inherits
[01:29:31.569]                     invokeRestart <- base::invokeRestart
[01:29:31.569]                     is.null <- base::is.null
[01:29:31.569]                     muffled <- FALSE
[01:29:31.569]                     if (inherits(cond, "message")) {
[01:29:31.569]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:31.569]                       if (muffled) 
[01:29:31.569]                         invokeRestart("muffleMessage")
[01:29:31.569]                     }
[01:29:31.569]                     else if (inherits(cond, "warning")) {
[01:29:31.569]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:31.569]                       if (muffled) 
[01:29:31.569]                         invokeRestart("muffleWarning")
[01:29:31.569]                     }
[01:29:31.569]                     else if (inherits(cond, "condition")) {
[01:29:31.569]                       if (!is.null(pattern)) {
[01:29:31.569]                         computeRestarts <- base::computeRestarts
[01:29:31.569]                         grepl <- base::grepl
[01:29:31.569]                         restarts <- computeRestarts(cond)
[01:29:31.569]                         for (restart in restarts) {
[01:29:31.569]                           name <- restart$name
[01:29:31.569]                           if (is.null(name)) 
[01:29:31.569]                             next
[01:29:31.569]                           if (!grepl(pattern, name)) 
[01:29:31.569]                             next
[01:29:31.569]                           invokeRestart(restart)
[01:29:31.569]                           muffled <- TRUE
[01:29:31.569]                           break
[01:29:31.569]                         }
[01:29:31.569]                       }
[01:29:31.569]                     }
[01:29:31.569]                     invisible(muffled)
[01:29:31.569]                   }
[01:29:31.569]                   muffleCondition(cond)
[01:29:31.569]                 })
[01:29:31.569]             }))
[01:29:31.569]             future::FutureResult(value = ...future.value$value, 
[01:29:31.569]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.569]                   ...future.rng), globalenv = if (FALSE) 
[01:29:31.569]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:31.569]                     ...future.globalenv.names))
[01:29:31.569]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:31.569]         }, condition = base::local({
[01:29:31.569]             c <- base::c
[01:29:31.569]             inherits <- base::inherits
[01:29:31.569]             invokeRestart <- base::invokeRestart
[01:29:31.569]             length <- base::length
[01:29:31.569]             list <- base::list
[01:29:31.569]             seq.int <- base::seq.int
[01:29:31.569]             signalCondition <- base::signalCondition
[01:29:31.569]             sys.calls <- base::sys.calls
[01:29:31.569]             `[[` <- base::`[[`
[01:29:31.569]             `+` <- base::`+`
[01:29:31.569]             `<<-` <- base::`<<-`
[01:29:31.569]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:31.569]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:31.569]                   3L)]
[01:29:31.569]             }
[01:29:31.569]             function(cond) {
[01:29:31.569]                 is_error <- inherits(cond, "error")
[01:29:31.569]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:31.569]                   NULL)
[01:29:31.569]                 if (is_error) {
[01:29:31.569]                   sessionInformation <- function() {
[01:29:31.569]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:31.569]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:31.569]                       search = base::search(), system = base::Sys.info())
[01:29:31.569]                   }
[01:29:31.569]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.569]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:31.569]                     cond$call), session = sessionInformation(), 
[01:29:31.569]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:31.569]                   signalCondition(cond)
[01:29:31.569]                 }
[01:29:31.569]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:31.569]                 "immediateCondition"))) {
[01:29:31.569]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:31.569]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.569]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:31.569]                   if (TRUE && !signal) {
[01:29:31.569]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.569]                     {
[01:29:31.569]                       inherits <- base::inherits
[01:29:31.569]                       invokeRestart <- base::invokeRestart
[01:29:31.569]                       is.null <- base::is.null
[01:29:31.569]                       muffled <- FALSE
[01:29:31.569]                       if (inherits(cond, "message")) {
[01:29:31.569]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.569]                         if (muffled) 
[01:29:31.569]                           invokeRestart("muffleMessage")
[01:29:31.569]                       }
[01:29:31.569]                       else if (inherits(cond, "warning")) {
[01:29:31.569]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.569]                         if (muffled) 
[01:29:31.569]                           invokeRestart("muffleWarning")
[01:29:31.569]                       }
[01:29:31.569]                       else if (inherits(cond, "condition")) {
[01:29:31.569]                         if (!is.null(pattern)) {
[01:29:31.569]                           computeRestarts <- base::computeRestarts
[01:29:31.569]                           grepl <- base::grepl
[01:29:31.569]                           restarts <- computeRestarts(cond)
[01:29:31.569]                           for (restart in restarts) {
[01:29:31.569]                             name <- restart$name
[01:29:31.569]                             if (is.null(name)) 
[01:29:31.569]                               next
[01:29:31.569]                             if (!grepl(pattern, name)) 
[01:29:31.569]                               next
[01:29:31.569]                             invokeRestart(restart)
[01:29:31.569]                             muffled <- TRUE
[01:29:31.569]                             break
[01:29:31.569]                           }
[01:29:31.569]                         }
[01:29:31.569]                       }
[01:29:31.569]                       invisible(muffled)
[01:29:31.569]                     }
[01:29:31.569]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.569]                   }
[01:29:31.569]                 }
[01:29:31.569]                 else {
[01:29:31.569]                   if (TRUE) {
[01:29:31.569]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.569]                     {
[01:29:31.569]                       inherits <- base::inherits
[01:29:31.569]                       invokeRestart <- base::invokeRestart
[01:29:31.569]                       is.null <- base::is.null
[01:29:31.569]                       muffled <- FALSE
[01:29:31.569]                       if (inherits(cond, "message")) {
[01:29:31.569]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.569]                         if (muffled) 
[01:29:31.569]                           invokeRestart("muffleMessage")
[01:29:31.569]                       }
[01:29:31.569]                       else if (inherits(cond, "warning")) {
[01:29:31.569]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.569]                         if (muffled) 
[01:29:31.569]                           invokeRestart("muffleWarning")
[01:29:31.569]                       }
[01:29:31.569]                       else if (inherits(cond, "condition")) {
[01:29:31.569]                         if (!is.null(pattern)) {
[01:29:31.569]                           computeRestarts <- base::computeRestarts
[01:29:31.569]                           grepl <- base::grepl
[01:29:31.569]                           restarts <- computeRestarts(cond)
[01:29:31.569]                           for (restart in restarts) {
[01:29:31.569]                             name <- restart$name
[01:29:31.569]                             if (is.null(name)) 
[01:29:31.569]                               next
[01:29:31.569]                             if (!grepl(pattern, name)) 
[01:29:31.569]                               next
[01:29:31.569]                             invokeRestart(restart)
[01:29:31.569]                             muffled <- TRUE
[01:29:31.569]                             break
[01:29:31.569]                           }
[01:29:31.569]                         }
[01:29:31.569]                       }
[01:29:31.569]                       invisible(muffled)
[01:29:31.569]                     }
[01:29:31.569]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.569]                   }
[01:29:31.569]                 }
[01:29:31.569]             }
[01:29:31.569]         }))
[01:29:31.569]     }, error = function(ex) {
[01:29:31.569]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:31.569]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.569]                 ...future.rng), started = ...future.startTime, 
[01:29:31.569]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:31.569]             version = "1.8"), class = "FutureResult")
[01:29:31.569]     }, finally = {
[01:29:31.569]         if (!identical(...future.workdir, getwd())) 
[01:29:31.569]             setwd(...future.workdir)
[01:29:31.569]         {
[01:29:31.569]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:31.569]                 ...future.oldOptions$nwarnings <- NULL
[01:29:31.569]             }
[01:29:31.569]             base::options(...future.oldOptions)
[01:29:31.569]             if (.Platform$OS.type == "windows") {
[01:29:31.569]                 old_names <- names(...future.oldEnvVars)
[01:29:31.569]                 envs <- base::Sys.getenv()
[01:29:31.569]                 names <- names(envs)
[01:29:31.569]                 common <- intersect(names, old_names)
[01:29:31.569]                 added <- setdiff(names, old_names)
[01:29:31.569]                 removed <- setdiff(old_names, names)
[01:29:31.569]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:31.569]                   envs[common]]
[01:29:31.569]                 NAMES <- toupper(changed)
[01:29:31.569]                 args <- list()
[01:29:31.569]                 for (kk in seq_along(NAMES)) {
[01:29:31.569]                   name <- changed[[kk]]
[01:29:31.569]                   NAME <- NAMES[[kk]]
[01:29:31.569]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.569]                     next
[01:29:31.569]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.569]                 }
[01:29:31.569]                 NAMES <- toupper(added)
[01:29:31.569]                 for (kk in seq_along(NAMES)) {
[01:29:31.569]                   name <- added[[kk]]
[01:29:31.569]                   NAME <- NAMES[[kk]]
[01:29:31.569]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.569]                     next
[01:29:31.569]                   args[[name]] <- ""
[01:29:31.569]                 }
[01:29:31.569]                 NAMES <- toupper(removed)
[01:29:31.569]                 for (kk in seq_along(NAMES)) {
[01:29:31.569]                   name <- removed[[kk]]
[01:29:31.569]                   NAME <- NAMES[[kk]]
[01:29:31.569]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.569]                     next
[01:29:31.569]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.569]                 }
[01:29:31.569]                 if (length(args) > 0) 
[01:29:31.569]                   base::do.call(base::Sys.setenv, args = args)
[01:29:31.569]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:31.569]             }
[01:29:31.569]             else {
[01:29:31.569]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:31.569]             }
[01:29:31.569]             {
[01:29:31.569]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:31.569]                   0L) {
[01:29:31.569]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:31.569]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:31.569]                   base::options(opts)
[01:29:31.569]                 }
[01:29:31.569]                 {
[01:29:31.569]                   {
[01:29:31.569]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:31.569]                     NULL
[01:29:31.569]                   }
[01:29:31.569]                   options(future.plan = NULL)
[01:29:31.569]                   if (is.na(NA_character_)) 
[01:29:31.569]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.569]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:31.569]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:31.569]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:31.569]                     envir = parent.frame()) 
[01:29:31.569]                   {
[01:29:31.569]                     if (is.function(workers)) 
[01:29:31.569]                       workers <- workers()
[01:29:31.569]                     workers <- structure(as.integer(workers), 
[01:29:31.569]                       class = class(workers))
[01:29:31.569]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:31.569]                       workers >= 1)
[01:29:31.569]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:31.569]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:31.569]                     }
[01:29:31.569]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:31.569]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:31.569]                       envir = envir)
[01:29:31.569]                     if (!future$lazy) 
[01:29:31.569]                       future <- run(future)
[01:29:31.569]                     invisible(future)
[01:29:31.569]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:31.569]                 }
[01:29:31.569]             }
[01:29:31.569]         }
[01:29:31.569]     })
[01:29:31.569]     if (TRUE) {
[01:29:31.569]         base::sink(type = "output", split = FALSE)
[01:29:31.569]         if (TRUE) {
[01:29:31.569]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:31.569]         }
[01:29:31.569]         else {
[01:29:31.569]             ...future.result["stdout"] <- base::list(NULL)
[01:29:31.569]         }
[01:29:31.569]         base::close(...future.stdout)
[01:29:31.569]         ...future.stdout <- NULL
[01:29:31.569]     }
[01:29:31.569]     ...future.result$conditions <- ...future.conditions
[01:29:31.569]     ...future.result$finished <- base::Sys.time()
[01:29:31.569]     ...future.result
[01:29:31.569] }
[01:29:31.575] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:31.575] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:31.575] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:31.576] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:31.576] MultisessionFuture started
[01:29:31.577] - Launch lazy future ... done
[01:29:31.577] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_4-742915'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96f75eba0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[01:29:31.596] receiveMessageFromWorker() for ClusterFuture ...
[01:29:31.596] - Validating connection of MultisessionFuture
[01:29:31.596] - received message: FutureResult
[01:29:31.597] - Received FutureResult
[01:29:31.597] - Erased future from FutureRegistry
[01:29:31.597] result() for ClusterFuture ...
[01:29:31.597] - result already collected: FutureResult
[01:29:31.597] result() for ClusterFuture ... done
[01:29:31.598] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.598] resolve() on list ...
[01:29:31.598]  recursive: 0
[01:29:31.598]  length: 4
[01:29:31.598] 
[01:29:31.599] Future #1
[01:29:31.599] result() for ClusterFuture ...
[01:29:31.599] - result already collected: FutureResult
[01:29:31.599] result() for ClusterFuture ... done
[01:29:31.599] result() for ClusterFuture ...
[01:29:31.599] - result already collected: FutureResult
[01:29:31.600] result() for ClusterFuture ... done
[01:29:31.600] signalConditionsASAP(MultisessionFuture, pos=1) ...
[01:29:31.600] - nx: 4
[01:29:31.600] - relay: TRUE
[01:29:31.600] - stdout: TRUE
[01:29:31.600] - signal: TRUE
[01:29:31.601] - resignal: FALSE
[01:29:31.601] - force: TRUE
[01:29:31.601] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:31.601] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[01:29:31.601]  - until=1
[01:29:31.601]  - relaying element #1
[01:29:31.602] result() for ClusterFuture ...
[01:29:31.602] - result already collected: FutureResult
[01:29:31.602] result() for ClusterFuture ... done
[01:29:31.602] result() for ClusterFuture ...
[01:29:31.602] - result already collected: FutureResult
[01:29:31.602] result() for ClusterFuture ... done
[01:29:31.603] result() for ClusterFuture ...
[01:29:31.603] - result already collected: FutureResult
[01:29:31.603] result() for ClusterFuture ... done
[01:29:31.603] result() for ClusterFuture ...
[01:29:31.603] - result already collected: FutureResult
[01:29:31.603] result() for ClusterFuture ... done
[01:29:31.604] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:31.604] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:31.604] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[01:29:31.604]  length: 3 (resolved future 1)
[01:29:31.604] Future #2
[01:29:31.605] result() for ClusterFuture ...
[01:29:31.605] - result already collected: FutureResult
[01:29:31.605] result() for ClusterFuture ... done
[01:29:31.605] result() for ClusterFuture ...
[01:29:31.605] - result already collected: FutureResult
[01:29:31.605] result() for ClusterFuture ... done
[01:29:31.606] signalConditionsASAP(MultisessionFuture, pos=2) ...
[01:29:31.606] - nx: 4
[01:29:31.606] - relay: TRUE
[01:29:31.606] - stdout: TRUE
[01:29:31.606] - signal: TRUE
[01:29:31.606] - resignal: FALSE
[01:29:31.606] - force: TRUE
[01:29:31.607] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:31.607] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[01:29:31.607]  - until=2
[01:29:31.607]  - relaying element #2
[01:29:31.607] result() for ClusterFuture ...
[01:29:31.607] - result already collected: FutureResult
[01:29:31.608] result() for ClusterFuture ... done
[01:29:31.608] result() for ClusterFuture ...
[01:29:31.608] - result already collected: FutureResult
[01:29:31.608] result() for ClusterFuture ... done
[01:29:31.608] result() for ClusterFuture ...
[01:29:31.608] - result already collected: FutureResult
[01:29:31.609] result() for ClusterFuture ... done
[01:29:31.609] result() for ClusterFuture ...
[01:29:31.609] - result already collected: FutureResult
[01:29:31.609] result() for ClusterFuture ... done
[01:29:31.609] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:31.609] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:31.610] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[01:29:31.610]  length: 2 (resolved future 2)
[01:29:31.610] Future #3
[01:29:31.610] result() for ClusterFuture ...
[01:29:31.610] - result already collected: FutureResult
[01:29:31.610] result() for ClusterFuture ... done
[01:29:31.611] result() for ClusterFuture ...
[01:29:31.611] - result already collected: FutureResult
[01:29:31.611] result() for ClusterFuture ... done
[01:29:31.611] signalConditionsASAP(MultisessionFuture, pos=3) ...
[01:29:31.611] - nx: 4
[01:29:31.611] - relay: TRUE
[01:29:31.612] - stdout: TRUE
[01:29:31.612] - signal: TRUE
[01:29:31.612] - resignal: FALSE
[01:29:31.612] - force: TRUE
[01:29:31.612] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:31.612] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[01:29:31.613]  - until=3
[01:29:31.613]  - relaying element #3
[01:29:31.613] result() for ClusterFuture ...
[01:29:31.613] - result already collected: FutureResult
[01:29:31.613] result() for ClusterFuture ... done
[01:29:31.613] result() for ClusterFuture ...
[01:29:31.614] - result already collected: FutureResult
[01:29:31.614] result() for ClusterFuture ... done
[01:29:31.614] result() for ClusterFuture ...
[01:29:31.614] - result already collected: FutureResult
[01:29:31.614] result() for ClusterFuture ... done
[01:29:31.614] result() for ClusterFuture ...
[01:29:31.615] - result already collected: FutureResult
[01:29:31.615] result() for ClusterFuture ... done
[01:29:31.615] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:31.615] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:31.615] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[01:29:31.615]  length: 1 (resolved future 3)
[01:29:31.616] Future #4
[01:29:31.616] result() for ClusterFuture ...
[01:29:31.616] - result already collected: FutureResult
[01:29:31.616] result() for ClusterFuture ... done
[01:29:31.616] result() for ClusterFuture ...
[01:29:31.616] - result already collected: FutureResult
[01:29:31.617] result() for ClusterFuture ... done
[01:29:31.617] signalConditionsASAP(MultisessionFuture, pos=4) ...
[01:29:31.617] - nx: 4
[01:29:31.617] - relay: TRUE
[01:29:31.617] - stdout: TRUE
[01:29:31.617] - signal: TRUE
[01:29:31.618] - resignal: FALSE
[01:29:31.618] - force: TRUE
[01:29:31.618] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:31.618] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[01:29:31.618]  - until=4
[01:29:31.618]  - relaying element #4
[01:29:31.618] result() for ClusterFuture ...
[01:29:31.619] - result already collected: FutureResult
[01:29:31.619] result() for ClusterFuture ... done
[01:29:31.619] result() for ClusterFuture ...
[01:29:31.619] - result already collected: FutureResult
[01:29:31.619] result() for ClusterFuture ... done
[01:29:31.619] result() for ClusterFuture ...
[01:29:31.620] - result already collected: FutureResult
[01:29:31.620] result() for ClusterFuture ... done
[01:29:31.620] result() for ClusterFuture ...
[01:29:31.620] - result already collected: FutureResult
[01:29:31.620] result() for ClusterFuture ... done
[01:29:31.620] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:31.621] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:31.621] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[01:29:31.621]  length: 0 (resolved future 4)
[01:29:31.621] Relaying remaining futures
[01:29:31.621] signalConditionsASAP(NULL, pos=0) ...
[01:29:31.621] - nx: 4
[01:29:31.622] - relay: TRUE
[01:29:31.622] - stdout: TRUE
[01:29:31.622] - signal: TRUE
[01:29:31.622] - resignal: FALSE
[01:29:31.622] - force: TRUE
[01:29:31.622] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:31.622] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[01:29:31.623] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:31.623] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[01:29:31.623] signalConditionsASAP(NULL, pos=0) ... done
[01:29:31.623] resolve() on list ... DONE
[01:29:31.623] result() for ClusterFuture ...
[01:29:31.624] - result already collected: FutureResult
[01:29:31.624] result() for ClusterFuture ... done
[01:29:31.624] result() for ClusterFuture ...
[01:29:31.624] - result already collected: FutureResult
[01:29:31.624] result() for ClusterFuture ... done
[01:29:31.624] result() for ClusterFuture ...
[01:29:31.625] - result already collected: FutureResult
[01:29:31.625] result() for ClusterFuture ... done
[01:29:31.625] result() for ClusterFuture ...
[01:29:31.625] - result already collected: FutureResult
[01:29:31.625] result() for ClusterFuture ... done
[01:29:31.625] result() for ClusterFuture ...
[01:29:31.626] - result already collected: FutureResult
[01:29:31.626] result() for ClusterFuture ... done
[01:29:31.626] result() for ClusterFuture ...
[01:29:31.626] - result already collected: FutureResult
[01:29:31.626] result() for ClusterFuture ... done
[01:29:31.626] result() for ClusterFuture ...
[01:29:31.626] - result already collected: FutureResult
[01:29:31.627] result() for ClusterFuture ... done
[01:29:31.627] result() for ClusterFuture ...
[01:29:31.627] - result already collected: FutureResult
[01:29:31.627] result() for ClusterFuture ... done
[[1]]
[1] 1

[[2]]
[1] 1

[[3]]
[1] 3

[[4]]
[1] 0

[01:29:31.628] getGlobalsAndPackages() ...
[01:29:31.628] Searching for globals...
[01:29:31.629] - globals found: [3] '{', 'sample', 'x'
[01:29:31.630] Searching for globals ... DONE
[01:29:31.630] Resolving globals: FALSE
[01:29:31.630] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:31.631] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:31.631] - globals: [1] 'x'
[01:29:31.631] 
[01:29:31.631] getGlobalsAndPackages() ... DONE
[01:29:31.632] run() for 'Future' ...
[01:29:31.632] - state: 'created'
[01:29:31.632] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:31.646] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.646] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:31.646]   - Field: 'node'
[01:29:31.647]   - Field: 'label'
[01:29:31.647]   - Field: 'local'
[01:29:31.647]   - Field: 'owner'
[01:29:31.647]   - Field: 'envir'
[01:29:31.647]   - Field: 'workers'
[01:29:31.648]   - Field: 'packages'
[01:29:31.648]   - Field: 'gc'
[01:29:31.648]   - Field: 'conditions'
[01:29:31.648]   - Field: 'persistent'
[01:29:31.648]   - Field: 'expr'
[01:29:31.648]   - Field: 'uuid'
[01:29:31.649]   - Field: 'seed'
[01:29:31.649]   - Field: 'version'
[01:29:31.649]   - Field: 'result'
[01:29:31.649]   - Field: 'asynchronous'
[01:29:31.649]   - Field: 'calls'
[01:29:31.649]   - Field: 'globals'
[01:29:31.650]   - Field: 'stdout'
[01:29:31.650]   - Field: 'earlySignal'
[01:29:31.650]   - Field: 'lazy'
[01:29:31.650]   - Field: 'state'
[01:29:31.650] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:31.651] - Launch lazy future ...
[01:29:31.651] Packages needed by the future expression (n = 0): <none>
[01:29:31.651] Packages needed by future strategies (n = 0): <none>
[01:29:31.652] {
[01:29:31.652]     {
[01:29:31.652]         {
[01:29:31.652]             ...future.startTime <- base::Sys.time()
[01:29:31.652]             {
[01:29:31.652]                 {
[01:29:31.652]                   {
[01:29:31.652]                     {
[01:29:31.652]                       {
[01:29:31.652]                         base::local({
[01:29:31.652]                           has_future <- base::requireNamespace("future", 
[01:29:31.652]                             quietly = TRUE)
[01:29:31.652]                           if (has_future) {
[01:29:31.652]                             ns <- base::getNamespace("future")
[01:29:31.652]                             version <- ns[[".package"]][["version"]]
[01:29:31.652]                             if (is.null(version)) 
[01:29:31.652]                               version <- utils::packageVersion("future")
[01:29:31.652]                           }
[01:29:31.652]                           else {
[01:29:31.652]                             version <- NULL
[01:29:31.652]                           }
[01:29:31.652]                           if (!has_future || version < "1.8.0") {
[01:29:31.652]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:31.652]                               "", base::R.version$version.string), 
[01:29:31.652]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:31.652]                                 base::R.version$platform, 8 * 
[01:29:31.652]                                   base::.Machine$sizeof.pointer), 
[01:29:31.652]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:31.652]                                 "release", "version")], collapse = " "), 
[01:29:31.652]                               hostname = base::Sys.info()[["nodename"]])
[01:29:31.652]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:31.652]                               info)
[01:29:31.652]                             info <- base::paste(info, collapse = "; ")
[01:29:31.652]                             if (!has_future) {
[01:29:31.652]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:31.652]                                 info)
[01:29:31.652]                             }
[01:29:31.652]                             else {
[01:29:31.652]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:31.652]                                 info, version)
[01:29:31.652]                             }
[01:29:31.652]                             base::stop(msg)
[01:29:31.652]                           }
[01:29:31.652]                         })
[01:29:31.652]                       }
[01:29:31.652]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:31.652]                       base::options(mc.cores = 1L)
[01:29:31.652]                     }
[01:29:31.652]                     options(future.plan = NULL)
[01:29:31.652]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.652]                     future::plan("default", .cleanup = FALSE, 
[01:29:31.652]                       .init = FALSE)
[01:29:31.652]                   }
[01:29:31.652]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[01:29:31.652]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[01:29:31.652]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[01:29:31.652]                 }
[01:29:31.652]                 ...future.workdir <- getwd()
[01:29:31.652]             }
[01:29:31.652]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:31.652]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:31.652]         }
[01:29:31.652]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:31.652]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:31.652]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:31.652]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:31.652]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:31.652]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:31.652]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:31.652]             base::names(...future.oldOptions))
[01:29:31.652]     }
[01:29:31.652]     if (FALSE) {
[01:29:31.652]     }
[01:29:31.652]     else {
[01:29:31.652]         if (TRUE) {
[01:29:31.652]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:31.652]                 open = "w")
[01:29:31.652]         }
[01:29:31.652]         else {
[01:29:31.652]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:31.652]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:31.652]         }
[01:29:31.652]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:31.652]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:31.652]             base::sink(type = "output", split = FALSE)
[01:29:31.652]             base::close(...future.stdout)
[01:29:31.652]         }, add = TRUE)
[01:29:31.652]     }
[01:29:31.652]     ...future.frame <- base::sys.nframe()
[01:29:31.652]     ...future.conditions <- base::list()
[01:29:31.652]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:31.652]     if (FALSE) {
[01:29:31.652]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:31.652]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:31.652]     }
[01:29:31.652]     ...future.result <- base::tryCatch({
[01:29:31.652]         base::withCallingHandlers({
[01:29:31.652]             ...future.value <- base::withVisible(base::local({
[01:29:31.652]                 ...future.makeSendCondition <- base::local({
[01:29:31.652]                   sendCondition <- NULL
[01:29:31.652]                   function(frame = 1L) {
[01:29:31.652]                     if (is.function(sendCondition)) 
[01:29:31.652]                       return(sendCondition)
[01:29:31.652]                     ns <- getNamespace("parallel")
[01:29:31.652]                     if (exists("sendData", mode = "function", 
[01:29:31.652]                       envir = ns)) {
[01:29:31.652]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:31.652]                         envir = ns)
[01:29:31.652]                       envir <- sys.frame(frame)
[01:29:31.652]                       master <- NULL
[01:29:31.652]                       while (!identical(envir, .GlobalEnv) && 
[01:29:31.652]                         !identical(envir, emptyenv())) {
[01:29:31.652]                         if (exists("master", mode = "list", envir = envir, 
[01:29:31.652]                           inherits = FALSE)) {
[01:29:31.652]                           master <- get("master", mode = "list", 
[01:29:31.652]                             envir = envir, inherits = FALSE)
[01:29:31.652]                           if (inherits(master, c("SOCKnode", 
[01:29:31.652]                             "SOCK0node"))) {
[01:29:31.652]                             sendCondition <<- function(cond) {
[01:29:31.652]                               data <- list(type = "VALUE", value = cond, 
[01:29:31.652]                                 success = TRUE)
[01:29:31.652]                               parallel_sendData(master, data)
[01:29:31.652]                             }
[01:29:31.652]                             return(sendCondition)
[01:29:31.652]                           }
[01:29:31.652]                         }
[01:29:31.652]                         frame <- frame + 1L
[01:29:31.652]                         envir <- sys.frame(frame)
[01:29:31.652]                       }
[01:29:31.652]                     }
[01:29:31.652]                     sendCondition <<- function(cond) NULL
[01:29:31.652]                   }
[01:29:31.652]                 })
[01:29:31.652]                 withCallingHandlers({
[01:29:31.652]                   {
[01:29:31.652]                     sample(x, size = 1L)
[01:29:31.652]                   }
[01:29:31.652]                 }, immediateCondition = function(cond) {
[01:29:31.652]                   sendCondition <- ...future.makeSendCondition()
[01:29:31.652]                   sendCondition(cond)
[01:29:31.652]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.652]                   {
[01:29:31.652]                     inherits <- base::inherits
[01:29:31.652]                     invokeRestart <- base::invokeRestart
[01:29:31.652]                     is.null <- base::is.null
[01:29:31.652]                     muffled <- FALSE
[01:29:31.652]                     if (inherits(cond, "message")) {
[01:29:31.652]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:31.652]                       if (muffled) 
[01:29:31.652]                         invokeRestart("muffleMessage")
[01:29:31.652]                     }
[01:29:31.652]                     else if (inherits(cond, "warning")) {
[01:29:31.652]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:31.652]                       if (muffled) 
[01:29:31.652]                         invokeRestart("muffleWarning")
[01:29:31.652]                     }
[01:29:31.652]                     else if (inherits(cond, "condition")) {
[01:29:31.652]                       if (!is.null(pattern)) {
[01:29:31.652]                         computeRestarts <- base::computeRestarts
[01:29:31.652]                         grepl <- base::grepl
[01:29:31.652]                         restarts <- computeRestarts(cond)
[01:29:31.652]                         for (restart in restarts) {
[01:29:31.652]                           name <- restart$name
[01:29:31.652]                           if (is.null(name)) 
[01:29:31.652]                             next
[01:29:31.652]                           if (!grepl(pattern, name)) 
[01:29:31.652]                             next
[01:29:31.652]                           invokeRestart(restart)
[01:29:31.652]                           muffled <- TRUE
[01:29:31.652]                           break
[01:29:31.652]                         }
[01:29:31.652]                       }
[01:29:31.652]                     }
[01:29:31.652]                     invisible(muffled)
[01:29:31.652]                   }
[01:29:31.652]                   muffleCondition(cond)
[01:29:31.652]                 })
[01:29:31.652]             }))
[01:29:31.652]             future::FutureResult(value = ...future.value$value, 
[01:29:31.652]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.652]                   ...future.rng), globalenv = if (FALSE) 
[01:29:31.652]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:31.652]                     ...future.globalenv.names))
[01:29:31.652]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:31.652]         }, condition = base::local({
[01:29:31.652]             c <- base::c
[01:29:31.652]             inherits <- base::inherits
[01:29:31.652]             invokeRestart <- base::invokeRestart
[01:29:31.652]             length <- base::length
[01:29:31.652]             list <- base::list
[01:29:31.652]             seq.int <- base::seq.int
[01:29:31.652]             signalCondition <- base::signalCondition
[01:29:31.652]             sys.calls <- base::sys.calls
[01:29:31.652]             `[[` <- base::`[[`
[01:29:31.652]             `+` <- base::`+`
[01:29:31.652]             `<<-` <- base::`<<-`
[01:29:31.652]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:31.652]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:31.652]                   3L)]
[01:29:31.652]             }
[01:29:31.652]             function(cond) {
[01:29:31.652]                 is_error <- inherits(cond, "error")
[01:29:31.652]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:31.652]                   NULL)
[01:29:31.652]                 if (is_error) {
[01:29:31.652]                   sessionInformation <- function() {
[01:29:31.652]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:31.652]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:31.652]                       search = base::search(), system = base::Sys.info())
[01:29:31.652]                   }
[01:29:31.652]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.652]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:31.652]                     cond$call), session = sessionInformation(), 
[01:29:31.652]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:31.652]                   signalCondition(cond)
[01:29:31.652]                 }
[01:29:31.652]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:31.652]                 "immediateCondition"))) {
[01:29:31.652]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:31.652]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.652]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:31.652]                   if (TRUE && !signal) {
[01:29:31.652]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.652]                     {
[01:29:31.652]                       inherits <- base::inherits
[01:29:31.652]                       invokeRestart <- base::invokeRestart
[01:29:31.652]                       is.null <- base::is.null
[01:29:31.652]                       muffled <- FALSE
[01:29:31.652]                       if (inherits(cond, "message")) {
[01:29:31.652]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.652]                         if (muffled) 
[01:29:31.652]                           invokeRestart("muffleMessage")
[01:29:31.652]                       }
[01:29:31.652]                       else if (inherits(cond, "warning")) {
[01:29:31.652]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.652]                         if (muffled) 
[01:29:31.652]                           invokeRestart("muffleWarning")
[01:29:31.652]                       }
[01:29:31.652]                       else if (inherits(cond, "condition")) {
[01:29:31.652]                         if (!is.null(pattern)) {
[01:29:31.652]                           computeRestarts <- base::computeRestarts
[01:29:31.652]                           grepl <- base::grepl
[01:29:31.652]                           restarts <- computeRestarts(cond)
[01:29:31.652]                           for (restart in restarts) {
[01:29:31.652]                             name <- restart$name
[01:29:31.652]                             if (is.null(name)) 
[01:29:31.652]                               next
[01:29:31.652]                             if (!grepl(pattern, name)) 
[01:29:31.652]                               next
[01:29:31.652]                             invokeRestart(restart)
[01:29:31.652]                             muffled <- TRUE
[01:29:31.652]                             break
[01:29:31.652]                           }
[01:29:31.652]                         }
[01:29:31.652]                       }
[01:29:31.652]                       invisible(muffled)
[01:29:31.652]                     }
[01:29:31.652]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.652]                   }
[01:29:31.652]                 }
[01:29:31.652]                 else {
[01:29:31.652]                   if (TRUE) {
[01:29:31.652]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.652]                     {
[01:29:31.652]                       inherits <- base::inherits
[01:29:31.652]                       invokeRestart <- base::invokeRestart
[01:29:31.652]                       is.null <- base::is.null
[01:29:31.652]                       muffled <- FALSE
[01:29:31.652]                       if (inherits(cond, "message")) {
[01:29:31.652]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.652]                         if (muffled) 
[01:29:31.652]                           invokeRestart("muffleMessage")
[01:29:31.652]                       }
[01:29:31.652]                       else if (inherits(cond, "warning")) {
[01:29:31.652]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.652]                         if (muffled) 
[01:29:31.652]                           invokeRestart("muffleWarning")
[01:29:31.652]                       }
[01:29:31.652]                       else if (inherits(cond, "condition")) {
[01:29:31.652]                         if (!is.null(pattern)) {
[01:29:31.652]                           computeRestarts <- base::computeRestarts
[01:29:31.652]                           grepl <- base::grepl
[01:29:31.652]                           restarts <- computeRestarts(cond)
[01:29:31.652]                           for (restart in restarts) {
[01:29:31.652]                             name <- restart$name
[01:29:31.652]                             if (is.null(name)) 
[01:29:31.652]                               next
[01:29:31.652]                             if (!grepl(pattern, name)) 
[01:29:31.652]                               next
[01:29:31.652]                             invokeRestart(restart)
[01:29:31.652]                             muffled <- TRUE
[01:29:31.652]                             break
[01:29:31.652]                           }
[01:29:31.652]                         }
[01:29:31.652]                       }
[01:29:31.652]                       invisible(muffled)
[01:29:31.652]                     }
[01:29:31.652]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.652]                   }
[01:29:31.652]                 }
[01:29:31.652]             }
[01:29:31.652]         }))
[01:29:31.652]     }, error = function(ex) {
[01:29:31.652]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:31.652]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.652]                 ...future.rng), started = ...future.startTime, 
[01:29:31.652]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:31.652]             version = "1.8"), class = "FutureResult")
[01:29:31.652]     }, finally = {
[01:29:31.652]         if (!identical(...future.workdir, getwd())) 
[01:29:31.652]             setwd(...future.workdir)
[01:29:31.652]         {
[01:29:31.652]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:31.652]                 ...future.oldOptions$nwarnings <- NULL
[01:29:31.652]             }
[01:29:31.652]             base::options(...future.oldOptions)
[01:29:31.652]             if (.Platform$OS.type == "windows") {
[01:29:31.652]                 old_names <- names(...future.oldEnvVars)
[01:29:31.652]                 envs <- base::Sys.getenv()
[01:29:31.652]                 names <- names(envs)
[01:29:31.652]                 common <- intersect(names, old_names)
[01:29:31.652]                 added <- setdiff(names, old_names)
[01:29:31.652]                 removed <- setdiff(old_names, names)
[01:29:31.652]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:31.652]                   envs[common]]
[01:29:31.652]                 NAMES <- toupper(changed)
[01:29:31.652]                 args <- list()
[01:29:31.652]                 for (kk in seq_along(NAMES)) {
[01:29:31.652]                   name <- changed[[kk]]
[01:29:31.652]                   NAME <- NAMES[[kk]]
[01:29:31.652]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.652]                     next
[01:29:31.652]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.652]                 }
[01:29:31.652]                 NAMES <- toupper(added)
[01:29:31.652]                 for (kk in seq_along(NAMES)) {
[01:29:31.652]                   name <- added[[kk]]
[01:29:31.652]                   NAME <- NAMES[[kk]]
[01:29:31.652]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.652]                     next
[01:29:31.652]                   args[[name]] <- ""
[01:29:31.652]                 }
[01:29:31.652]                 NAMES <- toupper(removed)
[01:29:31.652]                 for (kk in seq_along(NAMES)) {
[01:29:31.652]                   name <- removed[[kk]]
[01:29:31.652]                   NAME <- NAMES[[kk]]
[01:29:31.652]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.652]                     next
[01:29:31.652]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.652]                 }
[01:29:31.652]                 if (length(args) > 0) 
[01:29:31.652]                   base::do.call(base::Sys.setenv, args = args)
[01:29:31.652]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:31.652]             }
[01:29:31.652]             else {
[01:29:31.652]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:31.652]             }
[01:29:31.652]             {
[01:29:31.652]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:31.652]                   0L) {
[01:29:31.652]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:31.652]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:31.652]                   base::options(opts)
[01:29:31.652]                 }
[01:29:31.652]                 {
[01:29:31.652]                   {
[01:29:31.652]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:31.652]                     NULL
[01:29:31.652]                   }
[01:29:31.652]                   options(future.plan = NULL)
[01:29:31.652]                   if (is.na(NA_character_)) 
[01:29:31.652]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.652]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:31.652]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:31.652]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:31.652]                     envir = parent.frame()) 
[01:29:31.652]                   {
[01:29:31.652]                     if (is.function(workers)) 
[01:29:31.652]                       workers <- workers()
[01:29:31.652]                     workers <- structure(as.integer(workers), 
[01:29:31.652]                       class = class(workers))
[01:29:31.652]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:31.652]                       workers >= 1)
[01:29:31.652]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:31.652]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:31.652]                     }
[01:29:31.652]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:31.652]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:31.652]                       envir = envir)
[01:29:31.652]                     if (!future$lazy) 
[01:29:31.652]                       future <- run(future)
[01:29:31.652]                     invisible(future)
[01:29:31.652]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:31.652]                 }
[01:29:31.652]             }
[01:29:31.652]         }
[01:29:31.652]     })
[01:29:31.652]     if (TRUE) {
[01:29:31.652]         base::sink(type = "output", split = FALSE)
[01:29:31.652]         if (TRUE) {
[01:29:31.652]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:31.652]         }
[01:29:31.652]         else {
[01:29:31.652]             ...future.result["stdout"] <- base::list(NULL)
[01:29:31.652]         }
[01:29:31.652]         base::close(...future.stdout)
[01:29:31.652]         ...future.stdout <- NULL
[01:29:31.652]     }
[01:29:31.652]     ...future.result$conditions <- ...future.conditions
[01:29:31.652]     ...future.result$finished <- base::Sys.time()
[01:29:31.652]     ...future.result
[01:29:31.652] }
[01:29:31.657] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:31.657] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:31.658] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:31.658] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:31.659] MultisessionFuture started
[01:29:31.659] - Launch lazy future ... done
[01:29:31.659] run() for 'MultisessionFuture' ... done
[01:29:31.660] getGlobalsAndPackages() ...
[01:29:31.660] Searching for globals...
[01:29:31.661] - globals found: [3] '{', 'sample', 'x'
[01:29:31.661] Searching for globals ... DONE
[01:29:31.662] Resolving globals: FALSE
[01:29:31.662] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:31.663] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:31.663] - globals: [1] 'x'
[01:29:31.663] 
[01:29:31.663] getGlobalsAndPackages() ... DONE
[01:29:31.663] run() for 'Future' ...
[01:29:31.664] - state: 'created'
[01:29:31.664] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:31.678] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.678] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:31.678]   - Field: 'node'
[01:29:31.679]   - Field: 'label'
[01:29:31.679]   - Field: 'local'
[01:29:31.679]   - Field: 'owner'
[01:29:31.679]   - Field: 'envir'
[01:29:31.679]   - Field: 'workers'
[01:29:31.680]   - Field: 'packages'
[01:29:31.680]   - Field: 'gc'
[01:29:31.680]   - Field: 'conditions'
[01:29:31.680]   - Field: 'persistent'
[01:29:31.680]   - Field: 'expr'
[01:29:31.680]   - Field: 'uuid'
[01:29:31.681]   - Field: 'seed'
[01:29:31.681]   - Field: 'version'
[01:29:31.681]   - Field: 'result'
[01:29:31.681]   - Field: 'asynchronous'
[01:29:31.681]   - Field: 'calls'
[01:29:31.682]   - Field: 'globals'
[01:29:31.682]   - Field: 'stdout'
[01:29:31.682]   - Field: 'earlySignal'
[01:29:31.682]   - Field: 'lazy'
[01:29:31.682]   - Field: 'state'
[01:29:31.682] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:31.683] - Launch lazy future ...
[01:29:31.683] Packages needed by the future expression (n = 0): <none>
[01:29:31.683] Packages needed by future strategies (n = 0): <none>
[01:29:31.684] {
[01:29:31.684]     {
[01:29:31.684]         {
[01:29:31.684]             ...future.startTime <- base::Sys.time()
[01:29:31.684]             {
[01:29:31.684]                 {
[01:29:31.684]                   {
[01:29:31.684]                     {
[01:29:31.684]                       {
[01:29:31.684]                         base::local({
[01:29:31.684]                           has_future <- base::requireNamespace("future", 
[01:29:31.684]                             quietly = TRUE)
[01:29:31.684]                           if (has_future) {
[01:29:31.684]                             ns <- base::getNamespace("future")
[01:29:31.684]                             version <- ns[[".package"]][["version"]]
[01:29:31.684]                             if (is.null(version)) 
[01:29:31.684]                               version <- utils::packageVersion("future")
[01:29:31.684]                           }
[01:29:31.684]                           else {
[01:29:31.684]                             version <- NULL
[01:29:31.684]                           }
[01:29:31.684]                           if (!has_future || version < "1.8.0") {
[01:29:31.684]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:31.684]                               "", base::R.version$version.string), 
[01:29:31.684]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:31.684]                                 base::R.version$platform, 8 * 
[01:29:31.684]                                   base::.Machine$sizeof.pointer), 
[01:29:31.684]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:31.684]                                 "release", "version")], collapse = " "), 
[01:29:31.684]                               hostname = base::Sys.info()[["nodename"]])
[01:29:31.684]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:31.684]                               info)
[01:29:31.684]                             info <- base::paste(info, collapse = "; ")
[01:29:31.684]                             if (!has_future) {
[01:29:31.684]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:31.684]                                 info)
[01:29:31.684]                             }
[01:29:31.684]                             else {
[01:29:31.684]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:31.684]                                 info, version)
[01:29:31.684]                             }
[01:29:31.684]                             base::stop(msg)
[01:29:31.684]                           }
[01:29:31.684]                         })
[01:29:31.684]                       }
[01:29:31.684]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:31.684]                       base::options(mc.cores = 1L)
[01:29:31.684]                     }
[01:29:31.684]                     options(future.plan = NULL)
[01:29:31.684]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.684]                     future::plan("default", .cleanup = FALSE, 
[01:29:31.684]                       .init = FALSE)
[01:29:31.684]                   }
[01:29:31.684]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[01:29:31.684]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[01:29:31.684]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[01:29:31.684]                 }
[01:29:31.684]                 ...future.workdir <- getwd()
[01:29:31.684]             }
[01:29:31.684]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:31.684]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:31.684]         }
[01:29:31.684]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:31.684]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:31.684]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:31.684]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:31.684]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:31.684]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:31.684]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:31.684]             base::names(...future.oldOptions))
[01:29:31.684]     }
[01:29:31.684]     if (FALSE) {
[01:29:31.684]     }
[01:29:31.684]     else {
[01:29:31.684]         if (TRUE) {
[01:29:31.684]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:31.684]                 open = "w")
[01:29:31.684]         }
[01:29:31.684]         else {
[01:29:31.684]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:31.684]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:31.684]         }
[01:29:31.684]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:31.684]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:31.684]             base::sink(type = "output", split = FALSE)
[01:29:31.684]             base::close(...future.stdout)
[01:29:31.684]         }, add = TRUE)
[01:29:31.684]     }
[01:29:31.684]     ...future.frame <- base::sys.nframe()
[01:29:31.684]     ...future.conditions <- base::list()
[01:29:31.684]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:31.684]     if (FALSE) {
[01:29:31.684]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:31.684]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:31.684]     }
[01:29:31.684]     ...future.result <- base::tryCatch({
[01:29:31.684]         base::withCallingHandlers({
[01:29:31.684]             ...future.value <- base::withVisible(base::local({
[01:29:31.684]                 ...future.makeSendCondition <- base::local({
[01:29:31.684]                   sendCondition <- NULL
[01:29:31.684]                   function(frame = 1L) {
[01:29:31.684]                     if (is.function(sendCondition)) 
[01:29:31.684]                       return(sendCondition)
[01:29:31.684]                     ns <- getNamespace("parallel")
[01:29:31.684]                     if (exists("sendData", mode = "function", 
[01:29:31.684]                       envir = ns)) {
[01:29:31.684]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:31.684]                         envir = ns)
[01:29:31.684]                       envir <- sys.frame(frame)
[01:29:31.684]                       master <- NULL
[01:29:31.684]                       while (!identical(envir, .GlobalEnv) && 
[01:29:31.684]                         !identical(envir, emptyenv())) {
[01:29:31.684]                         if (exists("master", mode = "list", envir = envir, 
[01:29:31.684]                           inherits = FALSE)) {
[01:29:31.684]                           master <- get("master", mode = "list", 
[01:29:31.684]                             envir = envir, inherits = FALSE)
[01:29:31.684]                           if (inherits(master, c("SOCKnode", 
[01:29:31.684]                             "SOCK0node"))) {
[01:29:31.684]                             sendCondition <<- function(cond) {
[01:29:31.684]                               data <- list(type = "VALUE", value = cond, 
[01:29:31.684]                                 success = TRUE)
[01:29:31.684]                               parallel_sendData(master, data)
[01:29:31.684]                             }
[01:29:31.684]                             return(sendCondition)
[01:29:31.684]                           }
[01:29:31.684]                         }
[01:29:31.684]                         frame <- frame + 1L
[01:29:31.684]                         envir <- sys.frame(frame)
[01:29:31.684]                       }
[01:29:31.684]                     }
[01:29:31.684]                     sendCondition <<- function(cond) NULL
[01:29:31.684]                   }
[01:29:31.684]                 })
[01:29:31.684]                 withCallingHandlers({
[01:29:31.684]                   {
[01:29:31.684]                     sample(x, size = 1L)
[01:29:31.684]                   }
[01:29:31.684]                 }, immediateCondition = function(cond) {
[01:29:31.684]                   sendCondition <- ...future.makeSendCondition()
[01:29:31.684]                   sendCondition(cond)
[01:29:31.684]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.684]                   {
[01:29:31.684]                     inherits <- base::inherits
[01:29:31.684]                     invokeRestart <- base::invokeRestart
[01:29:31.684]                     is.null <- base::is.null
[01:29:31.684]                     muffled <- FALSE
[01:29:31.684]                     if (inherits(cond, "message")) {
[01:29:31.684]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:31.684]                       if (muffled) 
[01:29:31.684]                         invokeRestart("muffleMessage")
[01:29:31.684]                     }
[01:29:31.684]                     else if (inherits(cond, "warning")) {
[01:29:31.684]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:31.684]                       if (muffled) 
[01:29:31.684]                         invokeRestart("muffleWarning")
[01:29:31.684]                     }
[01:29:31.684]                     else if (inherits(cond, "condition")) {
[01:29:31.684]                       if (!is.null(pattern)) {
[01:29:31.684]                         computeRestarts <- base::computeRestarts
[01:29:31.684]                         grepl <- base::grepl
[01:29:31.684]                         restarts <- computeRestarts(cond)
[01:29:31.684]                         for (restart in restarts) {
[01:29:31.684]                           name <- restart$name
[01:29:31.684]                           if (is.null(name)) 
[01:29:31.684]                             next
[01:29:31.684]                           if (!grepl(pattern, name)) 
[01:29:31.684]                             next
[01:29:31.684]                           invokeRestart(restart)
[01:29:31.684]                           muffled <- TRUE
[01:29:31.684]                           break
[01:29:31.684]                         }
[01:29:31.684]                       }
[01:29:31.684]                     }
[01:29:31.684]                     invisible(muffled)
[01:29:31.684]                   }
[01:29:31.684]                   muffleCondition(cond)
[01:29:31.684]                 })
[01:29:31.684]             }))
[01:29:31.684]             future::FutureResult(value = ...future.value$value, 
[01:29:31.684]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.684]                   ...future.rng), globalenv = if (FALSE) 
[01:29:31.684]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:31.684]                     ...future.globalenv.names))
[01:29:31.684]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:31.684]         }, condition = base::local({
[01:29:31.684]             c <- base::c
[01:29:31.684]             inherits <- base::inherits
[01:29:31.684]             invokeRestart <- base::invokeRestart
[01:29:31.684]             length <- base::length
[01:29:31.684]             list <- base::list
[01:29:31.684]             seq.int <- base::seq.int
[01:29:31.684]             signalCondition <- base::signalCondition
[01:29:31.684]             sys.calls <- base::sys.calls
[01:29:31.684]             `[[` <- base::`[[`
[01:29:31.684]             `+` <- base::`+`
[01:29:31.684]             `<<-` <- base::`<<-`
[01:29:31.684]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:31.684]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:31.684]                   3L)]
[01:29:31.684]             }
[01:29:31.684]             function(cond) {
[01:29:31.684]                 is_error <- inherits(cond, "error")
[01:29:31.684]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:31.684]                   NULL)
[01:29:31.684]                 if (is_error) {
[01:29:31.684]                   sessionInformation <- function() {
[01:29:31.684]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:31.684]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:31.684]                       search = base::search(), system = base::Sys.info())
[01:29:31.684]                   }
[01:29:31.684]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.684]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:31.684]                     cond$call), session = sessionInformation(), 
[01:29:31.684]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:31.684]                   signalCondition(cond)
[01:29:31.684]                 }
[01:29:31.684]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:31.684]                 "immediateCondition"))) {
[01:29:31.684]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:31.684]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.684]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:31.684]                   if (TRUE && !signal) {
[01:29:31.684]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.684]                     {
[01:29:31.684]                       inherits <- base::inherits
[01:29:31.684]                       invokeRestart <- base::invokeRestart
[01:29:31.684]                       is.null <- base::is.null
[01:29:31.684]                       muffled <- FALSE
[01:29:31.684]                       if (inherits(cond, "message")) {
[01:29:31.684]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.684]                         if (muffled) 
[01:29:31.684]                           invokeRestart("muffleMessage")
[01:29:31.684]                       }
[01:29:31.684]                       else if (inherits(cond, "warning")) {
[01:29:31.684]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.684]                         if (muffled) 
[01:29:31.684]                           invokeRestart("muffleWarning")
[01:29:31.684]                       }
[01:29:31.684]                       else if (inherits(cond, "condition")) {
[01:29:31.684]                         if (!is.null(pattern)) {
[01:29:31.684]                           computeRestarts <- base::computeRestarts
[01:29:31.684]                           grepl <- base::grepl
[01:29:31.684]                           restarts <- computeRestarts(cond)
[01:29:31.684]                           for (restart in restarts) {
[01:29:31.684]                             name <- restart$name
[01:29:31.684]                             if (is.null(name)) 
[01:29:31.684]                               next
[01:29:31.684]                             if (!grepl(pattern, name)) 
[01:29:31.684]                               next
[01:29:31.684]                             invokeRestart(restart)
[01:29:31.684]                             muffled <- TRUE
[01:29:31.684]                             break
[01:29:31.684]                           }
[01:29:31.684]                         }
[01:29:31.684]                       }
[01:29:31.684]                       invisible(muffled)
[01:29:31.684]                     }
[01:29:31.684]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.684]                   }
[01:29:31.684]                 }
[01:29:31.684]                 else {
[01:29:31.684]                   if (TRUE) {
[01:29:31.684]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.684]                     {
[01:29:31.684]                       inherits <- base::inherits
[01:29:31.684]                       invokeRestart <- base::invokeRestart
[01:29:31.684]                       is.null <- base::is.null
[01:29:31.684]                       muffled <- FALSE
[01:29:31.684]                       if (inherits(cond, "message")) {
[01:29:31.684]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.684]                         if (muffled) 
[01:29:31.684]                           invokeRestart("muffleMessage")
[01:29:31.684]                       }
[01:29:31.684]                       else if (inherits(cond, "warning")) {
[01:29:31.684]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.684]                         if (muffled) 
[01:29:31.684]                           invokeRestart("muffleWarning")
[01:29:31.684]                       }
[01:29:31.684]                       else if (inherits(cond, "condition")) {
[01:29:31.684]                         if (!is.null(pattern)) {
[01:29:31.684]                           computeRestarts <- base::computeRestarts
[01:29:31.684]                           grepl <- base::grepl
[01:29:31.684]                           restarts <- computeRestarts(cond)
[01:29:31.684]                           for (restart in restarts) {
[01:29:31.684]                             name <- restart$name
[01:29:31.684]                             if (is.null(name)) 
[01:29:31.684]                               next
[01:29:31.684]                             if (!grepl(pattern, name)) 
[01:29:31.684]                               next
[01:29:31.684]                             invokeRestart(restart)
[01:29:31.684]                             muffled <- TRUE
[01:29:31.684]                             break
[01:29:31.684]                           }
[01:29:31.684]                         }
[01:29:31.684]                       }
[01:29:31.684]                       invisible(muffled)
[01:29:31.684]                     }
[01:29:31.684]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.684]                   }
[01:29:31.684]                 }
[01:29:31.684]             }
[01:29:31.684]         }))
[01:29:31.684]     }, error = function(ex) {
[01:29:31.684]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:31.684]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.684]                 ...future.rng), started = ...future.startTime, 
[01:29:31.684]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:31.684]             version = "1.8"), class = "FutureResult")
[01:29:31.684]     }, finally = {
[01:29:31.684]         if (!identical(...future.workdir, getwd())) 
[01:29:31.684]             setwd(...future.workdir)
[01:29:31.684]         {
[01:29:31.684]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:31.684]                 ...future.oldOptions$nwarnings <- NULL
[01:29:31.684]             }
[01:29:31.684]             base::options(...future.oldOptions)
[01:29:31.684]             if (.Platform$OS.type == "windows") {
[01:29:31.684]                 old_names <- names(...future.oldEnvVars)
[01:29:31.684]                 envs <- base::Sys.getenv()
[01:29:31.684]                 names <- names(envs)
[01:29:31.684]                 common <- intersect(names, old_names)
[01:29:31.684]                 added <- setdiff(names, old_names)
[01:29:31.684]                 removed <- setdiff(old_names, names)
[01:29:31.684]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:31.684]                   envs[common]]
[01:29:31.684]                 NAMES <- toupper(changed)
[01:29:31.684]                 args <- list()
[01:29:31.684]                 for (kk in seq_along(NAMES)) {
[01:29:31.684]                   name <- changed[[kk]]
[01:29:31.684]                   NAME <- NAMES[[kk]]
[01:29:31.684]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.684]                     next
[01:29:31.684]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.684]                 }
[01:29:31.684]                 NAMES <- toupper(added)
[01:29:31.684]                 for (kk in seq_along(NAMES)) {
[01:29:31.684]                   name <- added[[kk]]
[01:29:31.684]                   NAME <- NAMES[[kk]]
[01:29:31.684]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.684]                     next
[01:29:31.684]                   args[[name]] <- ""
[01:29:31.684]                 }
[01:29:31.684]                 NAMES <- toupper(removed)
[01:29:31.684]                 for (kk in seq_along(NAMES)) {
[01:29:31.684]                   name <- removed[[kk]]
[01:29:31.684]                   NAME <- NAMES[[kk]]
[01:29:31.684]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.684]                     next
[01:29:31.684]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.684]                 }
[01:29:31.684]                 if (length(args) > 0) 
[01:29:31.684]                   base::do.call(base::Sys.setenv, args = args)
[01:29:31.684]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:31.684]             }
[01:29:31.684]             else {
[01:29:31.684]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:31.684]             }
[01:29:31.684]             {
[01:29:31.684]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:31.684]                   0L) {
[01:29:31.684]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:31.684]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:31.684]                   base::options(opts)
[01:29:31.684]                 }
[01:29:31.684]                 {
[01:29:31.684]                   {
[01:29:31.684]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:31.684]                     NULL
[01:29:31.684]                   }
[01:29:31.684]                   options(future.plan = NULL)
[01:29:31.684]                   if (is.na(NA_character_)) 
[01:29:31.684]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.684]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:31.684]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:31.684]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:31.684]                     envir = parent.frame()) 
[01:29:31.684]                   {
[01:29:31.684]                     if (is.function(workers)) 
[01:29:31.684]                       workers <- workers()
[01:29:31.684]                     workers <- structure(as.integer(workers), 
[01:29:31.684]                       class = class(workers))
[01:29:31.684]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:31.684]                       workers >= 1)
[01:29:31.684]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:31.684]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:31.684]                     }
[01:29:31.684]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:31.684]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:31.684]                       envir = envir)
[01:29:31.684]                     if (!future$lazy) 
[01:29:31.684]                       future <- run(future)
[01:29:31.684]                     invisible(future)
[01:29:31.684]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:31.684]                 }
[01:29:31.684]             }
[01:29:31.684]         }
[01:29:31.684]     })
[01:29:31.684]     if (TRUE) {
[01:29:31.684]         base::sink(type = "output", split = FALSE)
[01:29:31.684]         if (TRUE) {
[01:29:31.684]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:31.684]         }
[01:29:31.684]         else {
[01:29:31.684]             ...future.result["stdout"] <- base::list(NULL)
[01:29:31.684]         }
[01:29:31.684]         base::close(...future.stdout)
[01:29:31.684]         ...future.stdout <- NULL
[01:29:31.684]     }
[01:29:31.684]     ...future.result$conditions <- ...future.conditions
[01:29:31.684]     ...future.result$finished <- base::Sys.time()
[01:29:31.684]     ...future.result
[01:29:31.684] }
[01:29:31.689] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:31.689] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:31.690] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:31.690] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:31.691] MultisessionFuture started
[01:29:31.691] - Launch lazy future ... done
[01:29:31.691] run() for 'MultisessionFuture' ... done
[01:29:31.692] getGlobalsAndPackages() ...
[01:29:31.692] Searching for globals...
[01:29:31.693] - globals found: [3] '{', 'sample', 'x'
[01:29:31.693] Searching for globals ... DONE
[01:29:31.693] Resolving globals: FALSE
[01:29:31.694] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:31.694] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:31.695] - globals: [1] 'x'
[01:29:31.695] 
[01:29:31.695] getGlobalsAndPackages() ... DONE
[01:29:31.695] run() for 'Future' ...
[01:29:31.695] - state: 'created'
[01:29:31.696] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:31.713] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.713] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:31.714]   - Field: 'node'
[01:29:31.714]   - Field: 'label'
[01:29:31.714]   - Field: 'local'
[01:29:31.714]   - Field: 'owner'
[01:29:31.714]   - Field: 'envir'
[01:29:31.715]   - Field: 'workers'
[01:29:31.715]   - Field: 'packages'
[01:29:31.715]   - Field: 'gc'
[01:29:31.715]   - Field: 'conditions'
[01:29:31.715]   - Field: 'persistent'
[01:29:31.715]   - Field: 'expr'
[01:29:31.716]   - Field: 'uuid'
[01:29:31.716]   - Field: 'seed'
[01:29:31.716]   - Field: 'version'
[01:29:31.716]   - Field: 'result'
[01:29:31.716]   - Field: 'asynchronous'
[01:29:31.716]   - Field: 'calls'
[01:29:31.717]   - Field: 'globals'
[01:29:31.717]   - Field: 'stdout'
[01:29:31.717]   - Field: 'earlySignal'
[01:29:31.717]   - Field: 'lazy'
[01:29:31.717]   - Field: 'state'
[01:29:31.718] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:31.718] - Launch lazy future ...
[01:29:31.718] Packages needed by the future expression (n = 0): <none>
[01:29:31.718] Packages needed by future strategies (n = 0): <none>
[01:29:31.719] {
[01:29:31.719]     {
[01:29:31.719]         {
[01:29:31.719]             ...future.startTime <- base::Sys.time()
[01:29:31.719]             {
[01:29:31.719]                 {
[01:29:31.719]                   {
[01:29:31.719]                     {
[01:29:31.719]                       {
[01:29:31.719]                         base::local({
[01:29:31.719]                           has_future <- base::requireNamespace("future", 
[01:29:31.719]                             quietly = TRUE)
[01:29:31.719]                           if (has_future) {
[01:29:31.719]                             ns <- base::getNamespace("future")
[01:29:31.719]                             version <- ns[[".package"]][["version"]]
[01:29:31.719]                             if (is.null(version)) 
[01:29:31.719]                               version <- utils::packageVersion("future")
[01:29:31.719]                           }
[01:29:31.719]                           else {
[01:29:31.719]                             version <- NULL
[01:29:31.719]                           }
[01:29:31.719]                           if (!has_future || version < "1.8.0") {
[01:29:31.719]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:31.719]                               "", base::R.version$version.string), 
[01:29:31.719]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:31.719]                                 base::R.version$platform, 8 * 
[01:29:31.719]                                   base::.Machine$sizeof.pointer), 
[01:29:31.719]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:31.719]                                 "release", "version")], collapse = " "), 
[01:29:31.719]                               hostname = base::Sys.info()[["nodename"]])
[01:29:31.719]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:31.719]                               info)
[01:29:31.719]                             info <- base::paste(info, collapse = "; ")
[01:29:31.719]                             if (!has_future) {
[01:29:31.719]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:31.719]                                 info)
[01:29:31.719]                             }
[01:29:31.719]                             else {
[01:29:31.719]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:31.719]                                 info, version)
[01:29:31.719]                             }
[01:29:31.719]                             base::stop(msg)
[01:29:31.719]                           }
[01:29:31.719]                         })
[01:29:31.719]                       }
[01:29:31.719]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:31.719]                       base::options(mc.cores = 1L)
[01:29:31.719]                     }
[01:29:31.719]                     options(future.plan = NULL)
[01:29:31.719]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.719]                     future::plan("default", .cleanup = FALSE, 
[01:29:31.719]                       .init = FALSE)
[01:29:31.719]                   }
[01:29:31.719]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[01:29:31.719]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[01:29:31.719]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[01:29:31.719]                 }
[01:29:31.719]                 ...future.workdir <- getwd()
[01:29:31.719]             }
[01:29:31.719]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:31.719]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:31.719]         }
[01:29:31.719]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:31.719]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:31.719]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:31.719]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:31.719]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:31.719]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:31.719]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:31.719]             base::names(...future.oldOptions))
[01:29:31.719]     }
[01:29:31.719]     if (FALSE) {
[01:29:31.719]     }
[01:29:31.719]     else {
[01:29:31.719]         if (TRUE) {
[01:29:31.719]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:31.719]                 open = "w")
[01:29:31.719]         }
[01:29:31.719]         else {
[01:29:31.719]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:31.719]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:31.719]         }
[01:29:31.719]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:31.719]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:31.719]             base::sink(type = "output", split = FALSE)
[01:29:31.719]             base::close(...future.stdout)
[01:29:31.719]         }, add = TRUE)
[01:29:31.719]     }
[01:29:31.719]     ...future.frame <- base::sys.nframe()
[01:29:31.719]     ...future.conditions <- base::list()
[01:29:31.719]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:31.719]     if (FALSE) {
[01:29:31.719]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:31.719]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:31.719]     }
[01:29:31.719]     ...future.result <- base::tryCatch({
[01:29:31.719]         base::withCallingHandlers({
[01:29:31.719]             ...future.value <- base::withVisible(base::local({
[01:29:31.719]                 ...future.makeSendCondition <- base::local({
[01:29:31.719]                   sendCondition <- NULL
[01:29:31.719]                   function(frame = 1L) {
[01:29:31.719]                     if (is.function(sendCondition)) 
[01:29:31.719]                       return(sendCondition)
[01:29:31.719]                     ns <- getNamespace("parallel")
[01:29:31.719]                     if (exists("sendData", mode = "function", 
[01:29:31.719]                       envir = ns)) {
[01:29:31.719]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:31.719]                         envir = ns)
[01:29:31.719]                       envir <- sys.frame(frame)
[01:29:31.719]                       master <- NULL
[01:29:31.719]                       while (!identical(envir, .GlobalEnv) && 
[01:29:31.719]                         !identical(envir, emptyenv())) {
[01:29:31.719]                         if (exists("master", mode = "list", envir = envir, 
[01:29:31.719]                           inherits = FALSE)) {
[01:29:31.719]                           master <- get("master", mode = "list", 
[01:29:31.719]                             envir = envir, inherits = FALSE)
[01:29:31.719]                           if (inherits(master, c("SOCKnode", 
[01:29:31.719]                             "SOCK0node"))) {
[01:29:31.719]                             sendCondition <<- function(cond) {
[01:29:31.719]                               data <- list(type = "VALUE", value = cond, 
[01:29:31.719]                                 success = TRUE)
[01:29:31.719]                               parallel_sendData(master, data)
[01:29:31.719]                             }
[01:29:31.719]                             return(sendCondition)
[01:29:31.719]                           }
[01:29:31.719]                         }
[01:29:31.719]                         frame <- frame + 1L
[01:29:31.719]                         envir <- sys.frame(frame)
[01:29:31.719]                       }
[01:29:31.719]                     }
[01:29:31.719]                     sendCondition <<- function(cond) NULL
[01:29:31.719]                   }
[01:29:31.719]                 })
[01:29:31.719]                 withCallingHandlers({
[01:29:31.719]                   {
[01:29:31.719]                     sample(x, size = 1L)
[01:29:31.719]                   }
[01:29:31.719]                 }, immediateCondition = function(cond) {
[01:29:31.719]                   sendCondition <- ...future.makeSendCondition()
[01:29:31.719]                   sendCondition(cond)
[01:29:31.719]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.719]                   {
[01:29:31.719]                     inherits <- base::inherits
[01:29:31.719]                     invokeRestart <- base::invokeRestart
[01:29:31.719]                     is.null <- base::is.null
[01:29:31.719]                     muffled <- FALSE
[01:29:31.719]                     if (inherits(cond, "message")) {
[01:29:31.719]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:31.719]                       if (muffled) 
[01:29:31.719]                         invokeRestart("muffleMessage")
[01:29:31.719]                     }
[01:29:31.719]                     else if (inherits(cond, "warning")) {
[01:29:31.719]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:31.719]                       if (muffled) 
[01:29:31.719]                         invokeRestart("muffleWarning")
[01:29:31.719]                     }
[01:29:31.719]                     else if (inherits(cond, "condition")) {
[01:29:31.719]                       if (!is.null(pattern)) {
[01:29:31.719]                         computeRestarts <- base::computeRestarts
[01:29:31.719]                         grepl <- base::grepl
[01:29:31.719]                         restarts <- computeRestarts(cond)
[01:29:31.719]                         for (restart in restarts) {
[01:29:31.719]                           name <- restart$name
[01:29:31.719]                           if (is.null(name)) 
[01:29:31.719]                             next
[01:29:31.719]                           if (!grepl(pattern, name)) 
[01:29:31.719]                             next
[01:29:31.719]                           invokeRestart(restart)
[01:29:31.719]                           muffled <- TRUE
[01:29:31.719]                           break
[01:29:31.719]                         }
[01:29:31.719]                       }
[01:29:31.719]                     }
[01:29:31.719]                     invisible(muffled)
[01:29:31.719]                   }
[01:29:31.719]                   muffleCondition(cond)
[01:29:31.719]                 })
[01:29:31.719]             }))
[01:29:31.719]             future::FutureResult(value = ...future.value$value, 
[01:29:31.719]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.719]                   ...future.rng), globalenv = if (FALSE) 
[01:29:31.719]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:31.719]                     ...future.globalenv.names))
[01:29:31.719]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:31.719]         }, condition = base::local({
[01:29:31.719]             c <- base::c
[01:29:31.719]             inherits <- base::inherits
[01:29:31.719]             invokeRestart <- base::invokeRestart
[01:29:31.719]             length <- base::length
[01:29:31.719]             list <- base::list
[01:29:31.719]             seq.int <- base::seq.int
[01:29:31.719]             signalCondition <- base::signalCondition
[01:29:31.719]             sys.calls <- base::sys.calls
[01:29:31.719]             `[[` <- base::`[[`
[01:29:31.719]             `+` <- base::`+`
[01:29:31.719]             `<<-` <- base::`<<-`
[01:29:31.719]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:31.719]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:31.719]                   3L)]
[01:29:31.719]             }
[01:29:31.719]             function(cond) {
[01:29:31.719]                 is_error <- inherits(cond, "error")
[01:29:31.719]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:31.719]                   NULL)
[01:29:31.719]                 if (is_error) {
[01:29:31.719]                   sessionInformation <- function() {
[01:29:31.719]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:31.719]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:31.719]                       search = base::search(), system = base::Sys.info())
[01:29:31.719]                   }
[01:29:31.719]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.719]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:31.719]                     cond$call), session = sessionInformation(), 
[01:29:31.719]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:31.719]                   signalCondition(cond)
[01:29:31.719]                 }
[01:29:31.719]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:31.719]                 "immediateCondition"))) {
[01:29:31.719]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:31.719]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.719]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:31.719]                   if (TRUE && !signal) {
[01:29:31.719]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.719]                     {
[01:29:31.719]                       inherits <- base::inherits
[01:29:31.719]                       invokeRestart <- base::invokeRestart
[01:29:31.719]                       is.null <- base::is.null
[01:29:31.719]                       muffled <- FALSE
[01:29:31.719]                       if (inherits(cond, "message")) {
[01:29:31.719]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.719]                         if (muffled) 
[01:29:31.719]                           invokeRestart("muffleMessage")
[01:29:31.719]                       }
[01:29:31.719]                       else if (inherits(cond, "warning")) {
[01:29:31.719]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.719]                         if (muffled) 
[01:29:31.719]                           invokeRestart("muffleWarning")
[01:29:31.719]                       }
[01:29:31.719]                       else if (inherits(cond, "condition")) {
[01:29:31.719]                         if (!is.null(pattern)) {
[01:29:31.719]                           computeRestarts <- base::computeRestarts
[01:29:31.719]                           grepl <- base::grepl
[01:29:31.719]                           restarts <- computeRestarts(cond)
[01:29:31.719]                           for (restart in restarts) {
[01:29:31.719]                             name <- restart$name
[01:29:31.719]                             if (is.null(name)) 
[01:29:31.719]                               next
[01:29:31.719]                             if (!grepl(pattern, name)) 
[01:29:31.719]                               next
[01:29:31.719]                             invokeRestart(restart)
[01:29:31.719]                             muffled <- TRUE
[01:29:31.719]                             break
[01:29:31.719]                           }
[01:29:31.719]                         }
[01:29:31.719]                       }
[01:29:31.719]                       invisible(muffled)
[01:29:31.719]                     }
[01:29:31.719]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.719]                   }
[01:29:31.719]                 }
[01:29:31.719]                 else {
[01:29:31.719]                   if (TRUE) {
[01:29:31.719]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.719]                     {
[01:29:31.719]                       inherits <- base::inherits
[01:29:31.719]                       invokeRestart <- base::invokeRestart
[01:29:31.719]                       is.null <- base::is.null
[01:29:31.719]                       muffled <- FALSE
[01:29:31.719]                       if (inherits(cond, "message")) {
[01:29:31.719]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.719]                         if (muffled) 
[01:29:31.719]                           invokeRestart("muffleMessage")
[01:29:31.719]                       }
[01:29:31.719]                       else if (inherits(cond, "warning")) {
[01:29:31.719]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.719]                         if (muffled) 
[01:29:31.719]                           invokeRestart("muffleWarning")
[01:29:31.719]                       }
[01:29:31.719]                       else if (inherits(cond, "condition")) {
[01:29:31.719]                         if (!is.null(pattern)) {
[01:29:31.719]                           computeRestarts <- base::computeRestarts
[01:29:31.719]                           grepl <- base::grepl
[01:29:31.719]                           restarts <- computeRestarts(cond)
[01:29:31.719]                           for (restart in restarts) {
[01:29:31.719]                             name <- restart$name
[01:29:31.719]                             if (is.null(name)) 
[01:29:31.719]                               next
[01:29:31.719]                             if (!grepl(pattern, name)) 
[01:29:31.719]                               next
[01:29:31.719]                             invokeRestart(restart)
[01:29:31.719]                             muffled <- TRUE
[01:29:31.719]                             break
[01:29:31.719]                           }
[01:29:31.719]                         }
[01:29:31.719]                       }
[01:29:31.719]                       invisible(muffled)
[01:29:31.719]                     }
[01:29:31.719]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.719]                   }
[01:29:31.719]                 }
[01:29:31.719]             }
[01:29:31.719]         }))
[01:29:31.719]     }, error = function(ex) {
[01:29:31.719]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:31.719]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.719]                 ...future.rng), started = ...future.startTime, 
[01:29:31.719]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:31.719]             version = "1.8"), class = "FutureResult")
[01:29:31.719]     }, finally = {
[01:29:31.719]         if (!identical(...future.workdir, getwd())) 
[01:29:31.719]             setwd(...future.workdir)
[01:29:31.719]         {
[01:29:31.719]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:31.719]                 ...future.oldOptions$nwarnings <- NULL
[01:29:31.719]             }
[01:29:31.719]             base::options(...future.oldOptions)
[01:29:31.719]             if (.Platform$OS.type == "windows") {
[01:29:31.719]                 old_names <- names(...future.oldEnvVars)
[01:29:31.719]                 envs <- base::Sys.getenv()
[01:29:31.719]                 names <- names(envs)
[01:29:31.719]                 common <- intersect(names, old_names)
[01:29:31.719]                 added <- setdiff(names, old_names)
[01:29:31.719]                 removed <- setdiff(old_names, names)
[01:29:31.719]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:31.719]                   envs[common]]
[01:29:31.719]                 NAMES <- toupper(changed)
[01:29:31.719]                 args <- list()
[01:29:31.719]                 for (kk in seq_along(NAMES)) {
[01:29:31.719]                   name <- changed[[kk]]
[01:29:31.719]                   NAME <- NAMES[[kk]]
[01:29:31.719]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.719]                     next
[01:29:31.719]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.719]                 }
[01:29:31.719]                 NAMES <- toupper(added)
[01:29:31.719]                 for (kk in seq_along(NAMES)) {
[01:29:31.719]                   name <- added[[kk]]
[01:29:31.719]                   NAME <- NAMES[[kk]]
[01:29:31.719]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.719]                     next
[01:29:31.719]                   args[[name]] <- ""
[01:29:31.719]                 }
[01:29:31.719]                 NAMES <- toupper(removed)
[01:29:31.719]                 for (kk in seq_along(NAMES)) {
[01:29:31.719]                   name <- removed[[kk]]
[01:29:31.719]                   NAME <- NAMES[[kk]]
[01:29:31.719]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.719]                     next
[01:29:31.719]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.719]                 }
[01:29:31.719]                 if (length(args) > 0) 
[01:29:31.719]                   base::do.call(base::Sys.setenv, args = args)
[01:29:31.719]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:31.719]             }
[01:29:31.719]             else {
[01:29:31.719]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:31.719]             }
[01:29:31.719]             {
[01:29:31.719]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:31.719]                   0L) {
[01:29:31.719]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:31.719]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:31.719]                   base::options(opts)
[01:29:31.719]                 }
[01:29:31.719]                 {
[01:29:31.719]                   {
[01:29:31.719]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:31.719]                     NULL
[01:29:31.719]                   }
[01:29:31.719]                   options(future.plan = NULL)
[01:29:31.719]                   if (is.na(NA_character_)) 
[01:29:31.719]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.719]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:31.719]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:31.719]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:31.719]                     envir = parent.frame()) 
[01:29:31.719]                   {
[01:29:31.719]                     if (is.function(workers)) 
[01:29:31.719]                       workers <- workers()
[01:29:31.719]                     workers <- structure(as.integer(workers), 
[01:29:31.719]                       class = class(workers))
[01:29:31.719]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:31.719]                       workers >= 1)
[01:29:31.719]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:31.719]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:31.719]                     }
[01:29:31.719]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:31.719]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:31.719]                       envir = envir)
[01:29:31.719]                     if (!future$lazy) 
[01:29:31.719]                       future <- run(future)
[01:29:31.719]                     invisible(future)
[01:29:31.719]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:31.719]                 }
[01:29:31.719]             }
[01:29:31.719]         }
[01:29:31.719]     })
[01:29:31.719]     if (TRUE) {
[01:29:31.719]         base::sink(type = "output", split = FALSE)
[01:29:31.719]         if (TRUE) {
[01:29:31.719]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:31.719]         }
[01:29:31.719]         else {
[01:29:31.719]             ...future.result["stdout"] <- base::list(NULL)
[01:29:31.719]         }
[01:29:31.719]         base::close(...future.stdout)
[01:29:31.719]         ...future.stdout <- NULL
[01:29:31.719]     }
[01:29:31.719]     ...future.result$conditions <- ...future.conditions
[01:29:31.719]     ...future.result$finished <- base::Sys.time()
[01:29:31.719]     ...future.result
[01:29:31.719] }
[01:29:31.724] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:31.737] receiveMessageFromWorker() for ClusterFuture ...
[01:29:31.737] - Validating connection of MultisessionFuture
[01:29:31.737] - received message: FutureResult
[01:29:31.738] - Received FutureResult
[01:29:31.738] - Erased future from FutureRegistry
[01:29:31.738] result() for ClusterFuture ...
[01:29:31.738] - result already collected: FutureResult
[01:29:31.738] result() for ClusterFuture ... done
[01:29:31.739] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:31.739] result() for ClusterFuture ...
[01:29:31.739] - result already collected: FutureResult
[01:29:31.739] result() for ClusterFuture ... done
[01:29:31.739] result() for ClusterFuture ...
[01:29:31.739] - result already collected: FutureResult
[01:29:31.740] result() for ClusterFuture ... done
[01:29:31.740] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:31.741] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:31.741] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:31.741] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:31.742] MultisessionFuture started
[01:29:31.742] - Launch lazy future ... done
[01:29:31.742] run() for 'MultisessionFuture' ... done
[01:29:31.743] getGlobalsAndPackages() ...
[01:29:31.743] Searching for globals...
[01:29:31.744] - globals found: [3] '{', 'sample', 'x'
[01:29:31.744] Searching for globals ... DONE
[01:29:31.745] Resolving globals: FALSE
[01:29:31.745] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:31.746] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:31.746] - globals: [1] 'x'
[01:29:31.746] 
[01:29:31.746] getGlobalsAndPackages() ... DONE
[01:29:31.746] run() for 'Future' ...
[01:29:31.747] - state: 'created'
[01:29:31.747] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:31.761] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.761] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:31.761]   - Field: 'node'
[01:29:31.762]   - Field: 'label'
[01:29:31.762]   - Field: 'local'
[01:29:31.762]   - Field: 'owner'
[01:29:31.762]   - Field: 'envir'
[01:29:31.762]   - Field: 'workers'
[01:29:31.763]   - Field: 'packages'
[01:29:31.763]   - Field: 'gc'
[01:29:31.763]   - Field: 'conditions'
[01:29:31.763]   - Field: 'persistent'
[01:29:31.763]   - Field: 'expr'
[01:29:31.763]   - Field: 'uuid'
[01:29:31.764]   - Field: 'seed'
[01:29:31.764]   - Field: 'version'
[01:29:31.764]   - Field: 'result'
[01:29:31.764]   - Field: 'asynchronous'
[01:29:31.764]   - Field: 'calls'
[01:29:31.764]   - Field: 'globals'
[01:29:31.765]   - Field: 'stdout'
[01:29:31.765]   - Field: 'earlySignal'
[01:29:31.765]   - Field: 'lazy'
[01:29:31.765]   - Field: 'state'
[01:29:31.765] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:31.766] - Launch lazy future ...
[01:29:31.766] Packages needed by the future expression (n = 0): <none>
[01:29:31.766] Packages needed by future strategies (n = 0): <none>
[01:29:31.767] {
[01:29:31.767]     {
[01:29:31.767]         {
[01:29:31.767]             ...future.startTime <- base::Sys.time()
[01:29:31.767]             {
[01:29:31.767]                 {
[01:29:31.767]                   {
[01:29:31.767]                     {
[01:29:31.767]                       {
[01:29:31.767]                         base::local({
[01:29:31.767]                           has_future <- base::requireNamespace("future", 
[01:29:31.767]                             quietly = TRUE)
[01:29:31.767]                           if (has_future) {
[01:29:31.767]                             ns <- base::getNamespace("future")
[01:29:31.767]                             version <- ns[[".package"]][["version"]]
[01:29:31.767]                             if (is.null(version)) 
[01:29:31.767]                               version <- utils::packageVersion("future")
[01:29:31.767]                           }
[01:29:31.767]                           else {
[01:29:31.767]                             version <- NULL
[01:29:31.767]                           }
[01:29:31.767]                           if (!has_future || version < "1.8.0") {
[01:29:31.767]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:31.767]                               "", base::R.version$version.string), 
[01:29:31.767]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:31.767]                                 base::R.version$platform, 8 * 
[01:29:31.767]                                   base::.Machine$sizeof.pointer), 
[01:29:31.767]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:31.767]                                 "release", "version")], collapse = " "), 
[01:29:31.767]                               hostname = base::Sys.info()[["nodename"]])
[01:29:31.767]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:31.767]                               info)
[01:29:31.767]                             info <- base::paste(info, collapse = "; ")
[01:29:31.767]                             if (!has_future) {
[01:29:31.767]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:31.767]                                 info)
[01:29:31.767]                             }
[01:29:31.767]                             else {
[01:29:31.767]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:31.767]                                 info, version)
[01:29:31.767]                             }
[01:29:31.767]                             base::stop(msg)
[01:29:31.767]                           }
[01:29:31.767]                         })
[01:29:31.767]                       }
[01:29:31.767]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:31.767]                       base::options(mc.cores = 1L)
[01:29:31.767]                     }
[01:29:31.767]                     options(future.plan = NULL)
[01:29:31.767]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.767]                     future::plan("default", .cleanup = FALSE, 
[01:29:31.767]                       .init = FALSE)
[01:29:31.767]                   }
[01:29:31.767]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[01:29:31.767]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[01:29:31.767]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[01:29:31.767]                 }
[01:29:31.767]                 ...future.workdir <- getwd()
[01:29:31.767]             }
[01:29:31.767]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:31.767]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:31.767]         }
[01:29:31.767]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:31.767]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:31.767]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:31.767]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:31.767]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:31.767]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:31.767]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:31.767]             base::names(...future.oldOptions))
[01:29:31.767]     }
[01:29:31.767]     if (FALSE) {
[01:29:31.767]     }
[01:29:31.767]     else {
[01:29:31.767]         if (TRUE) {
[01:29:31.767]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:31.767]                 open = "w")
[01:29:31.767]         }
[01:29:31.767]         else {
[01:29:31.767]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:31.767]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:31.767]         }
[01:29:31.767]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:31.767]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:31.767]             base::sink(type = "output", split = FALSE)
[01:29:31.767]             base::close(...future.stdout)
[01:29:31.767]         }, add = TRUE)
[01:29:31.767]     }
[01:29:31.767]     ...future.frame <- base::sys.nframe()
[01:29:31.767]     ...future.conditions <- base::list()
[01:29:31.767]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:31.767]     if (FALSE) {
[01:29:31.767]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:31.767]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:31.767]     }
[01:29:31.767]     ...future.result <- base::tryCatch({
[01:29:31.767]         base::withCallingHandlers({
[01:29:31.767]             ...future.value <- base::withVisible(base::local({
[01:29:31.767]                 ...future.makeSendCondition <- base::local({
[01:29:31.767]                   sendCondition <- NULL
[01:29:31.767]                   function(frame = 1L) {
[01:29:31.767]                     if (is.function(sendCondition)) 
[01:29:31.767]                       return(sendCondition)
[01:29:31.767]                     ns <- getNamespace("parallel")
[01:29:31.767]                     if (exists("sendData", mode = "function", 
[01:29:31.767]                       envir = ns)) {
[01:29:31.767]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:31.767]                         envir = ns)
[01:29:31.767]                       envir <- sys.frame(frame)
[01:29:31.767]                       master <- NULL
[01:29:31.767]                       while (!identical(envir, .GlobalEnv) && 
[01:29:31.767]                         !identical(envir, emptyenv())) {
[01:29:31.767]                         if (exists("master", mode = "list", envir = envir, 
[01:29:31.767]                           inherits = FALSE)) {
[01:29:31.767]                           master <- get("master", mode = "list", 
[01:29:31.767]                             envir = envir, inherits = FALSE)
[01:29:31.767]                           if (inherits(master, c("SOCKnode", 
[01:29:31.767]                             "SOCK0node"))) {
[01:29:31.767]                             sendCondition <<- function(cond) {
[01:29:31.767]                               data <- list(type = "VALUE", value = cond, 
[01:29:31.767]                                 success = TRUE)
[01:29:31.767]                               parallel_sendData(master, data)
[01:29:31.767]                             }
[01:29:31.767]                             return(sendCondition)
[01:29:31.767]                           }
[01:29:31.767]                         }
[01:29:31.767]                         frame <- frame + 1L
[01:29:31.767]                         envir <- sys.frame(frame)
[01:29:31.767]                       }
[01:29:31.767]                     }
[01:29:31.767]                     sendCondition <<- function(cond) NULL
[01:29:31.767]                   }
[01:29:31.767]                 })
[01:29:31.767]                 withCallingHandlers({
[01:29:31.767]                   {
[01:29:31.767]                     sample(x, size = 1L)
[01:29:31.767]                   }
[01:29:31.767]                 }, immediateCondition = function(cond) {
[01:29:31.767]                   sendCondition <- ...future.makeSendCondition()
[01:29:31.767]                   sendCondition(cond)
[01:29:31.767]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.767]                   {
[01:29:31.767]                     inherits <- base::inherits
[01:29:31.767]                     invokeRestart <- base::invokeRestart
[01:29:31.767]                     is.null <- base::is.null
[01:29:31.767]                     muffled <- FALSE
[01:29:31.767]                     if (inherits(cond, "message")) {
[01:29:31.767]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:31.767]                       if (muffled) 
[01:29:31.767]                         invokeRestart("muffleMessage")
[01:29:31.767]                     }
[01:29:31.767]                     else if (inherits(cond, "warning")) {
[01:29:31.767]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:31.767]                       if (muffled) 
[01:29:31.767]                         invokeRestart("muffleWarning")
[01:29:31.767]                     }
[01:29:31.767]                     else if (inherits(cond, "condition")) {
[01:29:31.767]                       if (!is.null(pattern)) {
[01:29:31.767]                         computeRestarts <- base::computeRestarts
[01:29:31.767]                         grepl <- base::grepl
[01:29:31.767]                         restarts <- computeRestarts(cond)
[01:29:31.767]                         for (restart in restarts) {
[01:29:31.767]                           name <- restart$name
[01:29:31.767]                           if (is.null(name)) 
[01:29:31.767]                             next
[01:29:31.767]                           if (!grepl(pattern, name)) 
[01:29:31.767]                             next
[01:29:31.767]                           invokeRestart(restart)
[01:29:31.767]                           muffled <- TRUE
[01:29:31.767]                           break
[01:29:31.767]                         }
[01:29:31.767]                       }
[01:29:31.767]                     }
[01:29:31.767]                     invisible(muffled)
[01:29:31.767]                   }
[01:29:31.767]                   muffleCondition(cond)
[01:29:31.767]                 })
[01:29:31.767]             }))
[01:29:31.767]             future::FutureResult(value = ...future.value$value, 
[01:29:31.767]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.767]                   ...future.rng), globalenv = if (FALSE) 
[01:29:31.767]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:31.767]                     ...future.globalenv.names))
[01:29:31.767]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:31.767]         }, condition = base::local({
[01:29:31.767]             c <- base::c
[01:29:31.767]             inherits <- base::inherits
[01:29:31.767]             invokeRestart <- base::invokeRestart
[01:29:31.767]             length <- base::length
[01:29:31.767]             list <- base::list
[01:29:31.767]             seq.int <- base::seq.int
[01:29:31.767]             signalCondition <- base::signalCondition
[01:29:31.767]             sys.calls <- base::sys.calls
[01:29:31.767]             `[[` <- base::`[[`
[01:29:31.767]             `+` <- base::`+`
[01:29:31.767]             `<<-` <- base::`<<-`
[01:29:31.767]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:31.767]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:31.767]                   3L)]
[01:29:31.767]             }
[01:29:31.767]             function(cond) {
[01:29:31.767]                 is_error <- inherits(cond, "error")
[01:29:31.767]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:31.767]                   NULL)
[01:29:31.767]                 if (is_error) {
[01:29:31.767]                   sessionInformation <- function() {
[01:29:31.767]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:31.767]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:31.767]                       search = base::search(), system = base::Sys.info())
[01:29:31.767]                   }
[01:29:31.767]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.767]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:31.767]                     cond$call), session = sessionInformation(), 
[01:29:31.767]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:31.767]                   signalCondition(cond)
[01:29:31.767]                 }
[01:29:31.767]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:31.767]                 "immediateCondition"))) {
[01:29:31.767]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:31.767]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.767]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:31.767]                   if (TRUE && !signal) {
[01:29:31.767]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.767]                     {
[01:29:31.767]                       inherits <- base::inherits
[01:29:31.767]                       invokeRestart <- base::invokeRestart
[01:29:31.767]                       is.null <- base::is.null
[01:29:31.767]                       muffled <- FALSE
[01:29:31.767]                       if (inherits(cond, "message")) {
[01:29:31.767]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.767]                         if (muffled) 
[01:29:31.767]                           invokeRestart("muffleMessage")
[01:29:31.767]                       }
[01:29:31.767]                       else if (inherits(cond, "warning")) {
[01:29:31.767]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.767]                         if (muffled) 
[01:29:31.767]                           invokeRestart("muffleWarning")
[01:29:31.767]                       }
[01:29:31.767]                       else if (inherits(cond, "condition")) {
[01:29:31.767]                         if (!is.null(pattern)) {
[01:29:31.767]                           computeRestarts <- base::computeRestarts
[01:29:31.767]                           grepl <- base::grepl
[01:29:31.767]                           restarts <- computeRestarts(cond)
[01:29:31.767]                           for (restart in restarts) {
[01:29:31.767]                             name <- restart$name
[01:29:31.767]                             if (is.null(name)) 
[01:29:31.767]                               next
[01:29:31.767]                             if (!grepl(pattern, name)) 
[01:29:31.767]                               next
[01:29:31.767]                             invokeRestart(restart)
[01:29:31.767]                             muffled <- TRUE
[01:29:31.767]                             break
[01:29:31.767]                           }
[01:29:31.767]                         }
[01:29:31.767]                       }
[01:29:31.767]                       invisible(muffled)
[01:29:31.767]                     }
[01:29:31.767]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.767]                   }
[01:29:31.767]                 }
[01:29:31.767]                 else {
[01:29:31.767]                   if (TRUE) {
[01:29:31.767]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.767]                     {
[01:29:31.767]                       inherits <- base::inherits
[01:29:31.767]                       invokeRestart <- base::invokeRestart
[01:29:31.767]                       is.null <- base::is.null
[01:29:31.767]                       muffled <- FALSE
[01:29:31.767]                       if (inherits(cond, "message")) {
[01:29:31.767]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.767]                         if (muffled) 
[01:29:31.767]                           invokeRestart("muffleMessage")
[01:29:31.767]                       }
[01:29:31.767]                       else if (inherits(cond, "warning")) {
[01:29:31.767]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.767]                         if (muffled) 
[01:29:31.767]                           invokeRestart("muffleWarning")
[01:29:31.767]                       }
[01:29:31.767]                       else if (inherits(cond, "condition")) {
[01:29:31.767]                         if (!is.null(pattern)) {
[01:29:31.767]                           computeRestarts <- base::computeRestarts
[01:29:31.767]                           grepl <- base::grepl
[01:29:31.767]                           restarts <- computeRestarts(cond)
[01:29:31.767]                           for (restart in restarts) {
[01:29:31.767]                             name <- restart$name
[01:29:31.767]                             if (is.null(name)) 
[01:29:31.767]                               next
[01:29:31.767]                             if (!grepl(pattern, name)) 
[01:29:31.767]                               next
[01:29:31.767]                             invokeRestart(restart)
[01:29:31.767]                             muffled <- TRUE
[01:29:31.767]                             break
[01:29:31.767]                           }
[01:29:31.767]                         }
[01:29:31.767]                       }
[01:29:31.767]                       invisible(muffled)
[01:29:31.767]                     }
[01:29:31.767]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.767]                   }
[01:29:31.767]                 }
[01:29:31.767]             }
[01:29:31.767]         }))
[01:29:31.767]     }, error = function(ex) {
[01:29:31.767]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:31.767]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.767]                 ...future.rng), started = ...future.startTime, 
[01:29:31.767]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:31.767]             version = "1.8"), class = "FutureResult")
[01:29:31.767]     }, finally = {
[01:29:31.767]         if (!identical(...future.workdir, getwd())) 
[01:29:31.767]             setwd(...future.workdir)
[01:29:31.767]         {
[01:29:31.767]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:31.767]                 ...future.oldOptions$nwarnings <- NULL
[01:29:31.767]             }
[01:29:31.767]             base::options(...future.oldOptions)
[01:29:31.767]             if (.Platform$OS.type == "windows") {
[01:29:31.767]                 old_names <- names(...future.oldEnvVars)
[01:29:31.767]                 envs <- base::Sys.getenv()
[01:29:31.767]                 names <- names(envs)
[01:29:31.767]                 common <- intersect(names, old_names)
[01:29:31.767]                 added <- setdiff(names, old_names)
[01:29:31.767]                 removed <- setdiff(old_names, names)
[01:29:31.767]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:31.767]                   envs[common]]
[01:29:31.767]                 NAMES <- toupper(changed)
[01:29:31.767]                 args <- list()
[01:29:31.767]                 for (kk in seq_along(NAMES)) {
[01:29:31.767]                   name <- changed[[kk]]
[01:29:31.767]                   NAME <- NAMES[[kk]]
[01:29:31.767]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.767]                     next
[01:29:31.767]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.767]                 }
[01:29:31.767]                 NAMES <- toupper(added)
[01:29:31.767]                 for (kk in seq_along(NAMES)) {
[01:29:31.767]                   name <- added[[kk]]
[01:29:31.767]                   NAME <- NAMES[[kk]]
[01:29:31.767]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.767]                     next
[01:29:31.767]                   args[[name]] <- ""
[01:29:31.767]                 }
[01:29:31.767]                 NAMES <- toupper(removed)
[01:29:31.767]                 for (kk in seq_along(NAMES)) {
[01:29:31.767]                   name <- removed[[kk]]
[01:29:31.767]                   NAME <- NAMES[[kk]]
[01:29:31.767]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.767]                     next
[01:29:31.767]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.767]                 }
[01:29:31.767]                 if (length(args) > 0) 
[01:29:31.767]                   base::do.call(base::Sys.setenv, args = args)
[01:29:31.767]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:31.767]             }
[01:29:31.767]             else {
[01:29:31.767]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:31.767]             }
[01:29:31.767]             {
[01:29:31.767]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:31.767]                   0L) {
[01:29:31.767]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:31.767]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:31.767]                   base::options(opts)
[01:29:31.767]                 }
[01:29:31.767]                 {
[01:29:31.767]                   {
[01:29:31.767]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:31.767]                     NULL
[01:29:31.767]                   }
[01:29:31.767]                   options(future.plan = NULL)
[01:29:31.767]                   if (is.na(NA_character_)) 
[01:29:31.767]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.767]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:31.767]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:31.767]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:31.767]                     envir = parent.frame()) 
[01:29:31.767]                   {
[01:29:31.767]                     if (is.function(workers)) 
[01:29:31.767]                       workers <- workers()
[01:29:31.767]                     workers <- structure(as.integer(workers), 
[01:29:31.767]                       class = class(workers))
[01:29:31.767]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:31.767]                       workers >= 1)
[01:29:31.767]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:31.767]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:31.767]                     }
[01:29:31.767]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:31.767]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:31.767]                       envir = envir)
[01:29:31.767]                     if (!future$lazy) 
[01:29:31.767]                       future <- run(future)
[01:29:31.767]                     invisible(future)
[01:29:31.767]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:31.767]                 }
[01:29:31.767]             }
[01:29:31.767]         }
[01:29:31.767]     })
[01:29:31.767]     if (TRUE) {
[01:29:31.767]         base::sink(type = "output", split = FALSE)
[01:29:31.767]         if (TRUE) {
[01:29:31.767]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:31.767]         }
[01:29:31.767]         else {
[01:29:31.767]             ...future.result["stdout"] <- base::list(NULL)
[01:29:31.767]         }
[01:29:31.767]         base::close(...future.stdout)
[01:29:31.767]         ...future.stdout <- NULL
[01:29:31.767]     }
[01:29:31.767]     ...future.result$conditions <- ...future.conditions
[01:29:31.767]     ...future.result$finished <- base::Sys.time()
[01:29:31.767]     ...future.result
[01:29:31.767] }
[01:29:31.772] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:31.784] receiveMessageFromWorker() for ClusterFuture ...
[01:29:31.784] - Validating connection of MultisessionFuture
[01:29:31.784] - received message: FutureResult
[01:29:31.785] - Received FutureResult
[01:29:31.785] - Erased future from FutureRegistry
[01:29:31.785] result() for ClusterFuture ...
[01:29:31.785] - result already collected: FutureResult
[01:29:31.785] result() for ClusterFuture ... done
[01:29:31.785] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:31.786] result() for ClusterFuture ...
[01:29:31.786] - result already collected: FutureResult
[01:29:31.786] result() for ClusterFuture ... done
[01:29:31.786] result() for ClusterFuture ...
[01:29:31.786] - result already collected: FutureResult
[01:29:31.787] result() for ClusterFuture ... done
[01:29:31.787] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:31.788] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:31.788] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:31.788] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:31.789] MultisessionFuture started
[01:29:31.789] - Launch lazy future ... done
[01:29:31.789] run() for 'MultisessionFuture' ... done
[01:29:31.790] result() for ClusterFuture ...
[01:29:31.790] - result already collected: FutureResult
[01:29:31.790] result() for ClusterFuture ... done
[01:29:31.790] result() for ClusterFuture ...
[01:29:31.790] - result already collected: FutureResult
[01:29:31.790] result() for ClusterFuture ... done
[01:29:31.791] result() for ClusterFuture ...
[01:29:31.791] - result already collected: FutureResult
[01:29:31.791] result() for ClusterFuture ... done
[01:29:31.791] result() for ClusterFuture ...
[01:29:31.791] - result already collected: FutureResult
[01:29:31.792] result() for ClusterFuture ... done
[01:29:31.792] result() for ClusterFuture ...
[01:29:31.792] receiveMessageFromWorker() for ClusterFuture ...
[01:29:31.792] - Validating connection of MultisessionFuture
[01:29:31.792] - received message: FutureResult
[01:29:31.793] - Received FutureResult
[01:29:31.793] - Erased future from FutureRegistry
[01:29:31.793] result() for ClusterFuture ...
[01:29:31.793] - result already collected: FutureResult
[01:29:31.793] result() for ClusterFuture ... done
[01:29:31.793] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:31.794] result() for ClusterFuture ... done
[01:29:31.794] result() for ClusterFuture ...
[01:29:31.794] - result already collected: FutureResult
[01:29:31.794] result() for ClusterFuture ... done
[01:29:31.794] result() for ClusterFuture ...
[01:29:31.794] receiveMessageFromWorker() for ClusterFuture ...
[01:29:31.795] - Validating connection of MultisessionFuture
[01:29:31.805] - received message: FutureResult
[01:29:31.806] - Received FutureResult
[01:29:31.806] - Erased future from FutureRegistry
[01:29:31.806] result() for ClusterFuture ...
[01:29:31.806] - result already collected: FutureResult
[01:29:31.806] result() for ClusterFuture ... done
[01:29:31.806] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:31.807] result() for ClusterFuture ... done
[01:29:31.807] result() for ClusterFuture ...
[01:29:31.807] - result already collected: FutureResult
[01:29:31.807] result() for ClusterFuture ... done
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[01:29:31.808] getGlobalsAndPackages() ...
[01:29:31.808] Searching for globals...
[01:29:31.809] - globals found: [3] '{', 'sample', 'x'
[01:29:31.810] Searching for globals ... DONE
[01:29:31.810] Resolving globals: FALSE
[01:29:31.810] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:31.811] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:31.811] - globals: [1] 'x'
[01:29:31.811] 
[01:29:31.811] getGlobalsAndPackages() ... DONE
[01:29:31.812] run() for 'Future' ...
[01:29:31.812] - state: 'created'
[01:29:31.812] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:31.831] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.831] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:31.832]   - Field: 'node'
[01:29:31.832]   - Field: 'label'
[01:29:31.832]   - Field: 'local'
[01:29:31.833]   - Field: 'owner'
[01:29:31.833]   - Field: 'envir'
[01:29:31.833]   - Field: 'workers'
[01:29:31.833]   - Field: 'packages'
[01:29:31.834]   - Field: 'gc'
[01:29:31.834]   - Field: 'conditions'
[01:29:31.834]   - Field: 'persistent'
[01:29:31.834]   - Field: 'expr'
[01:29:31.835]   - Field: 'uuid'
[01:29:31.835]   - Field: 'seed'
[01:29:31.835]   - Field: 'version'
[01:29:31.836]   - Field: 'result'
[01:29:31.836]   - Field: 'asynchronous'
[01:29:31.836]   - Field: 'calls'
[01:29:31.836]   - Field: 'globals'
[01:29:31.837]   - Field: 'stdout'
[01:29:31.837]   - Field: 'earlySignal'
[01:29:31.837]   - Field: 'lazy'
[01:29:31.837]   - Field: 'state'
[01:29:31.838] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:31.838] - Launch lazy future ...
[01:29:31.839] Packages needed by the future expression (n = 0): <none>
[01:29:31.839] Packages needed by future strategies (n = 0): <none>
[01:29:31.840] {
[01:29:31.840]     {
[01:29:31.840]         {
[01:29:31.840]             ...future.startTime <- base::Sys.time()
[01:29:31.840]             {
[01:29:31.840]                 {
[01:29:31.840]                   {
[01:29:31.840]                     {
[01:29:31.840]                       {
[01:29:31.840]                         base::local({
[01:29:31.840]                           has_future <- base::requireNamespace("future", 
[01:29:31.840]                             quietly = TRUE)
[01:29:31.840]                           if (has_future) {
[01:29:31.840]                             ns <- base::getNamespace("future")
[01:29:31.840]                             version <- ns[[".package"]][["version"]]
[01:29:31.840]                             if (is.null(version)) 
[01:29:31.840]                               version <- utils::packageVersion("future")
[01:29:31.840]                           }
[01:29:31.840]                           else {
[01:29:31.840]                             version <- NULL
[01:29:31.840]                           }
[01:29:31.840]                           if (!has_future || version < "1.8.0") {
[01:29:31.840]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:31.840]                               "", base::R.version$version.string), 
[01:29:31.840]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:31.840]                                 base::R.version$platform, 8 * 
[01:29:31.840]                                   base::.Machine$sizeof.pointer), 
[01:29:31.840]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:31.840]                                 "release", "version")], collapse = " "), 
[01:29:31.840]                               hostname = base::Sys.info()[["nodename"]])
[01:29:31.840]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:31.840]                               info)
[01:29:31.840]                             info <- base::paste(info, collapse = "; ")
[01:29:31.840]                             if (!has_future) {
[01:29:31.840]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:31.840]                                 info)
[01:29:31.840]                             }
[01:29:31.840]                             else {
[01:29:31.840]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:31.840]                                 info, version)
[01:29:31.840]                             }
[01:29:31.840]                             base::stop(msg)
[01:29:31.840]                           }
[01:29:31.840]                         })
[01:29:31.840]                       }
[01:29:31.840]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:31.840]                       base::options(mc.cores = 1L)
[01:29:31.840]                     }
[01:29:31.840]                     options(future.plan = NULL)
[01:29:31.840]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.840]                     future::plan("default", .cleanup = FALSE, 
[01:29:31.840]                       .init = FALSE)
[01:29:31.840]                   }
[01:29:31.840]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[01:29:31.840]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[01:29:31.840]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[01:29:31.840]                 }
[01:29:31.840]                 ...future.workdir <- getwd()
[01:29:31.840]             }
[01:29:31.840]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:31.840]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:31.840]         }
[01:29:31.840]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:31.840]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:31.840]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:31.840]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:31.840]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:31.840]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:31.840]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:31.840]             base::names(...future.oldOptions))
[01:29:31.840]     }
[01:29:31.840]     if (FALSE) {
[01:29:31.840]     }
[01:29:31.840]     else {
[01:29:31.840]         if (TRUE) {
[01:29:31.840]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:31.840]                 open = "w")
[01:29:31.840]         }
[01:29:31.840]         else {
[01:29:31.840]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:31.840]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:31.840]         }
[01:29:31.840]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:31.840]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:31.840]             base::sink(type = "output", split = FALSE)
[01:29:31.840]             base::close(...future.stdout)
[01:29:31.840]         }, add = TRUE)
[01:29:31.840]     }
[01:29:31.840]     ...future.frame <- base::sys.nframe()
[01:29:31.840]     ...future.conditions <- base::list()
[01:29:31.840]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:31.840]     if (FALSE) {
[01:29:31.840]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:31.840]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:31.840]     }
[01:29:31.840]     ...future.result <- base::tryCatch({
[01:29:31.840]         base::withCallingHandlers({
[01:29:31.840]             ...future.value <- base::withVisible(base::local({
[01:29:31.840]                 ...future.makeSendCondition <- base::local({
[01:29:31.840]                   sendCondition <- NULL
[01:29:31.840]                   function(frame = 1L) {
[01:29:31.840]                     if (is.function(sendCondition)) 
[01:29:31.840]                       return(sendCondition)
[01:29:31.840]                     ns <- getNamespace("parallel")
[01:29:31.840]                     if (exists("sendData", mode = "function", 
[01:29:31.840]                       envir = ns)) {
[01:29:31.840]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:31.840]                         envir = ns)
[01:29:31.840]                       envir <- sys.frame(frame)
[01:29:31.840]                       master <- NULL
[01:29:31.840]                       while (!identical(envir, .GlobalEnv) && 
[01:29:31.840]                         !identical(envir, emptyenv())) {
[01:29:31.840]                         if (exists("master", mode = "list", envir = envir, 
[01:29:31.840]                           inherits = FALSE)) {
[01:29:31.840]                           master <- get("master", mode = "list", 
[01:29:31.840]                             envir = envir, inherits = FALSE)
[01:29:31.840]                           if (inherits(master, c("SOCKnode", 
[01:29:31.840]                             "SOCK0node"))) {
[01:29:31.840]                             sendCondition <<- function(cond) {
[01:29:31.840]                               data <- list(type = "VALUE", value = cond, 
[01:29:31.840]                                 success = TRUE)
[01:29:31.840]                               parallel_sendData(master, data)
[01:29:31.840]                             }
[01:29:31.840]                             return(sendCondition)
[01:29:31.840]                           }
[01:29:31.840]                         }
[01:29:31.840]                         frame <- frame + 1L
[01:29:31.840]                         envir <- sys.frame(frame)
[01:29:31.840]                       }
[01:29:31.840]                     }
[01:29:31.840]                     sendCondition <<- function(cond) NULL
[01:29:31.840]                   }
[01:29:31.840]                 })
[01:29:31.840]                 withCallingHandlers({
[01:29:31.840]                   {
[01:29:31.840]                     sample(x, size = 1L)
[01:29:31.840]                   }
[01:29:31.840]                 }, immediateCondition = function(cond) {
[01:29:31.840]                   sendCondition <- ...future.makeSendCondition()
[01:29:31.840]                   sendCondition(cond)
[01:29:31.840]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.840]                   {
[01:29:31.840]                     inherits <- base::inherits
[01:29:31.840]                     invokeRestart <- base::invokeRestart
[01:29:31.840]                     is.null <- base::is.null
[01:29:31.840]                     muffled <- FALSE
[01:29:31.840]                     if (inherits(cond, "message")) {
[01:29:31.840]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:31.840]                       if (muffled) 
[01:29:31.840]                         invokeRestart("muffleMessage")
[01:29:31.840]                     }
[01:29:31.840]                     else if (inherits(cond, "warning")) {
[01:29:31.840]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:31.840]                       if (muffled) 
[01:29:31.840]                         invokeRestart("muffleWarning")
[01:29:31.840]                     }
[01:29:31.840]                     else if (inherits(cond, "condition")) {
[01:29:31.840]                       if (!is.null(pattern)) {
[01:29:31.840]                         computeRestarts <- base::computeRestarts
[01:29:31.840]                         grepl <- base::grepl
[01:29:31.840]                         restarts <- computeRestarts(cond)
[01:29:31.840]                         for (restart in restarts) {
[01:29:31.840]                           name <- restart$name
[01:29:31.840]                           if (is.null(name)) 
[01:29:31.840]                             next
[01:29:31.840]                           if (!grepl(pattern, name)) 
[01:29:31.840]                             next
[01:29:31.840]                           invokeRestart(restart)
[01:29:31.840]                           muffled <- TRUE
[01:29:31.840]                           break
[01:29:31.840]                         }
[01:29:31.840]                       }
[01:29:31.840]                     }
[01:29:31.840]                     invisible(muffled)
[01:29:31.840]                   }
[01:29:31.840]                   muffleCondition(cond)
[01:29:31.840]                 })
[01:29:31.840]             }))
[01:29:31.840]             future::FutureResult(value = ...future.value$value, 
[01:29:31.840]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.840]                   ...future.rng), globalenv = if (FALSE) 
[01:29:31.840]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:31.840]                     ...future.globalenv.names))
[01:29:31.840]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:31.840]         }, condition = base::local({
[01:29:31.840]             c <- base::c
[01:29:31.840]             inherits <- base::inherits
[01:29:31.840]             invokeRestart <- base::invokeRestart
[01:29:31.840]             length <- base::length
[01:29:31.840]             list <- base::list
[01:29:31.840]             seq.int <- base::seq.int
[01:29:31.840]             signalCondition <- base::signalCondition
[01:29:31.840]             sys.calls <- base::sys.calls
[01:29:31.840]             `[[` <- base::`[[`
[01:29:31.840]             `+` <- base::`+`
[01:29:31.840]             `<<-` <- base::`<<-`
[01:29:31.840]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:31.840]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:31.840]                   3L)]
[01:29:31.840]             }
[01:29:31.840]             function(cond) {
[01:29:31.840]                 is_error <- inherits(cond, "error")
[01:29:31.840]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:31.840]                   NULL)
[01:29:31.840]                 if (is_error) {
[01:29:31.840]                   sessionInformation <- function() {
[01:29:31.840]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:31.840]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:31.840]                       search = base::search(), system = base::Sys.info())
[01:29:31.840]                   }
[01:29:31.840]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.840]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:31.840]                     cond$call), session = sessionInformation(), 
[01:29:31.840]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:31.840]                   signalCondition(cond)
[01:29:31.840]                 }
[01:29:31.840]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:31.840]                 "immediateCondition"))) {
[01:29:31.840]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:31.840]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.840]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:31.840]                   if (TRUE && !signal) {
[01:29:31.840]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.840]                     {
[01:29:31.840]                       inherits <- base::inherits
[01:29:31.840]                       invokeRestart <- base::invokeRestart
[01:29:31.840]                       is.null <- base::is.null
[01:29:31.840]                       muffled <- FALSE
[01:29:31.840]                       if (inherits(cond, "message")) {
[01:29:31.840]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.840]                         if (muffled) 
[01:29:31.840]                           invokeRestart("muffleMessage")
[01:29:31.840]                       }
[01:29:31.840]                       else if (inherits(cond, "warning")) {
[01:29:31.840]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.840]                         if (muffled) 
[01:29:31.840]                           invokeRestart("muffleWarning")
[01:29:31.840]                       }
[01:29:31.840]                       else if (inherits(cond, "condition")) {
[01:29:31.840]                         if (!is.null(pattern)) {
[01:29:31.840]                           computeRestarts <- base::computeRestarts
[01:29:31.840]                           grepl <- base::grepl
[01:29:31.840]                           restarts <- computeRestarts(cond)
[01:29:31.840]                           for (restart in restarts) {
[01:29:31.840]                             name <- restart$name
[01:29:31.840]                             if (is.null(name)) 
[01:29:31.840]                               next
[01:29:31.840]                             if (!grepl(pattern, name)) 
[01:29:31.840]                               next
[01:29:31.840]                             invokeRestart(restart)
[01:29:31.840]                             muffled <- TRUE
[01:29:31.840]                             break
[01:29:31.840]                           }
[01:29:31.840]                         }
[01:29:31.840]                       }
[01:29:31.840]                       invisible(muffled)
[01:29:31.840]                     }
[01:29:31.840]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.840]                   }
[01:29:31.840]                 }
[01:29:31.840]                 else {
[01:29:31.840]                   if (TRUE) {
[01:29:31.840]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.840]                     {
[01:29:31.840]                       inherits <- base::inherits
[01:29:31.840]                       invokeRestart <- base::invokeRestart
[01:29:31.840]                       is.null <- base::is.null
[01:29:31.840]                       muffled <- FALSE
[01:29:31.840]                       if (inherits(cond, "message")) {
[01:29:31.840]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.840]                         if (muffled) 
[01:29:31.840]                           invokeRestart("muffleMessage")
[01:29:31.840]                       }
[01:29:31.840]                       else if (inherits(cond, "warning")) {
[01:29:31.840]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.840]                         if (muffled) 
[01:29:31.840]                           invokeRestart("muffleWarning")
[01:29:31.840]                       }
[01:29:31.840]                       else if (inherits(cond, "condition")) {
[01:29:31.840]                         if (!is.null(pattern)) {
[01:29:31.840]                           computeRestarts <- base::computeRestarts
[01:29:31.840]                           grepl <- base::grepl
[01:29:31.840]                           restarts <- computeRestarts(cond)
[01:29:31.840]                           for (restart in restarts) {
[01:29:31.840]                             name <- restart$name
[01:29:31.840]                             if (is.null(name)) 
[01:29:31.840]                               next
[01:29:31.840]                             if (!grepl(pattern, name)) 
[01:29:31.840]                               next
[01:29:31.840]                             invokeRestart(restart)
[01:29:31.840]                             muffled <- TRUE
[01:29:31.840]                             break
[01:29:31.840]                           }
[01:29:31.840]                         }
[01:29:31.840]                       }
[01:29:31.840]                       invisible(muffled)
[01:29:31.840]                     }
[01:29:31.840]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.840]                   }
[01:29:31.840]                 }
[01:29:31.840]             }
[01:29:31.840]         }))
[01:29:31.840]     }, error = function(ex) {
[01:29:31.840]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:31.840]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.840]                 ...future.rng), started = ...future.startTime, 
[01:29:31.840]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:31.840]             version = "1.8"), class = "FutureResult")
[01:29:31.840]     }, finally = {
[01:29:31.840]         if (!identical(...future.workdir, getwd())) 
[01:29:31.840]             setwd(...future.workdir)
[01:29:31.840]         {
[01:29:31.840]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:31.840]                 ...future.oldOptions$nwarnings <- NULL
[01:29:31.840]             }
[01:29:31.840]             base::options(...future.oldOptions)
[01:29:31.840]             if (.Platform$OS.type == "windows") {
[01:29:31.840]                 old_names <- names(...future.oldEnvVars)
[01:29:31.840]                 envs <- base::Sys.getenv()
[01:29:31.840]                 names <- names(envs)
[01:29:31.840]                 common <- intersect(names, old_names)
[01:29:31.840]                 added <- setdiff(names, old_names)
[01:29:31.840]                 removed <- setdiff(old_names, names)
[01:29:31.840]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:31.840]                   envs[common]]
[01:29:31.840]                 NAMES <- toupper(changed)
[01:29:31.840]                 args <- list()
[01:29:31.840]                 for (kk in seq_along(NAMES)) {
[01:29:31.840]                   name <- changed[[kk]]
[01:29:31.840]                   NAME <- NAMES[[kk]]
[01:29:31.840]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.840]                     next
[01:29:31.840]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.840]                 }
[01:29:31.840]                 NAMES <- toupper(added)
[01:29:31.840]                 for (kk in seq_along(NAMES)) {
[01:29:31.840]                   name <- added[[kk]]
[01:29:31.840]                   NAME <- NAMES[[kk]]
[01:29:31.840]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.840]                     next
[01:29:31.840]                   args[[name]] <- ""
[01:29:31.840]                 }
[01:29:31.840]                 NAMES <- toupper(removed)
[01:29:31.840]                 for (kk in seq_along(NAMES)) {
[01:29:31.840]                   name <- removed[[kk]]
[01:29:31.840]                   NAME <- NAMES[[kk]]
[01:29:31.840]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.840]                     next
[01:29:31.840]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.840]                 }
[01:29:31.840]                 if (length(args) > 0) 
[01:29:31.840]                   base::do.call(base::Sys.setenv, args = args)
[01:29:31.840]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:31.840]             }
[01:29:31.840]             else {
[01:29:31.840]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:31.840]             }
[01:29:31.840]             {
[01:29:31.840]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:31.840]                   0L) {
[01:29:31.840]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:31.840]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:31.840]                   base::options(opts)
[01:29:31.840]                 }
[01:29:31.840]                 {
[01:29:31.840]                   {
[01:29:31.840]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:31.840]                     NULL
[01:29:31.840]                   }
[01:29:31.840]                   options(future.plan = NULL)
[01:29:31.840]                   if (is.na(NA_character_)) 
[01:29:31.840]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.840]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:31.840]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:31.840]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:31.840]                     envir = parent.frame()) 
[01:29:31.840]                   {
[01:29:31.840]                     if (is.function(workers)) 
[01:29:31.840]                       workers <- workers()
[01:29:31.840]                     workers <- structure(as.integer(workers), 
[01:29:31.840]                       class = class(workers))
[01:29:31.840]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:31.840]                       workers >= 1)
[01:29:31.840]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:31.840]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:31.840]                     }
[01:29:31.840]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:31.840]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:31.840]                       envir = envir)
[01:29:31.840]                     if (!future$lazy) 
[01:29:31.840]                       future <- run(future)
[01:29:31.840]                     invisible(future)
[01:29:31.840]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:31.840]                 }
[01:29:31.840]             }
[01:29:31.840]         }
[01:29:31.840]     })
[01:29:31.840]     if (TRUE) {
[01:29:31.840]         base::sink(type = "output", split = FALSE)
[01:29:31.840]         if (TRUE) {
[01:29:31.840]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:31.840]         }
[01:29:31.840]         else {
[01:29:31.840]             ...future.result["stdout"] <- base::list(NULL)
[01:29:31.840]         }
[01:29:31.840]         base::close(...future.stdout)
[01:29:31.840]         ...future.stdout <- NULL
[01:29:31.840]     }
[01:29:31.840]     ...future.result$conditions <- ...future.conditions
[01:29:31.840]     ...future.result$finished <- base::Sys.time()
[01:29:31.840]     ...future.result
[01:29:31.840] }
[01:29:31.848] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:31.849] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:31.849] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:31.849] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:31.850] MultisessionFuture started
[01:29:31.850] - Launch lazy future ... done
[01:29:31.851] run() for 'MultisessionFuture' ... done
[01:29:31.851] getGlobalsAndPackages() ...
[01:29:31.852] Searching for globals...
[01:29:31.853] - globals found: [3] '{', 'sample', 'x'
[01:29:31.853] Searching for globals ... DONE
[01:29:31.853] Resolving globals: FALSE
[01:29:31.854] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:31.854] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:31.855] - globals: [1] 'x'
[01:29:31.855] 
[01:29:31.855] getGlobalsAndPackages() ... DONE
[01:29:31.855] run() for 'Future' ...
[01:29:31.855] - state: 'created'
[01:29:31.856] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:31.871] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.871] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:31.871]   - Field: 'node'
[01:29:31.872]   - Field: 'label'
[01:29:31.872]   - Field: 'local'
[01:29:31.872]   - Field: 'owner'
[01:29:31.872]   - Field: 'envir'
[01:29:31.872]   - Field: 'workers'
[01:29:31.873]   - Field: 'packages'
[01:29:31.873]   - Field: 'gc'
[01:29:31.873]   - Field: 'conditions'
[01:29:31.873]   - Field: 'persistent'
[01:29:31.873]   - Field: 'expr'
[01:29:31.874]   - Field: 'uuid'
[01:29:31.874]   - Field: 'seed'
[01:29:31.874]   - Field: 'version'
[01:29:31.874]   - Field: 'result'
[01:29:31.874]   - Field: 'asynchronous'
[01:29:31.874]   - Field: 'calls'
[01:29:31.875]   - Field: 'globals'
[01:29:31.875]   - Field: 'stdout'
[01:29:31.875]   - Field: 'earlySignal'
[01:29:31.875]   - Field: 'lazy'
[01:29:31.875]   - Field: 'state'
[01:29:31.876] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:31.876] - Launch lazy future ...
[01:29:31.876] Packages needed by the future expression (n = 0): <none>
[01:29:31.876] Packages needed by future strategies (n = 0): <none>
[01:29:31.877] {
[01:29:31.877]     {
[01:29:31.877]         {
[01:29:31.877]             ...future.startTime <- base::Sys.time()
[01:29:31.877]             {
[01:29:31.877]                 {
[01:29:31.877]                   {
[01:29:31.877]                     {
[01:29:31.877]                       {
[01:29:31.877]                         base::local({
[01:29:31.877]                           has_future <- base::requireNamespace("future", 
[01:29:31.877]                             quietly = TRUE)
[01:29:31.877]                           if (has_future) {
[01:29:31.877]                             ns <- base::getNamespace("future")
[01:29:31.877]                             version <- ns[[".package"]][["version"]]
[01:29:31.877]                             if (is.null(version)) 
[01:29:31.877]                               version <- utils::packageVersion("future")
[01:29:31.877]                           }
[01:29:31.877]                           else {
[01:29:31.877]                             version <- NULL
[01:29:31.877]                           }
[01:29:31.877]                           if (!has_future || version < "1.8.0") {
[01:29:31.877]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:31.877]                               "", base::R.version$version.string), 
[01:29:31.877]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:31.877]                                 base::R.version$platform, 8 * 
[01:29:31.877]                                   base::.Machine$sizeof.pointer), 
[01:29:31.877]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:31.877]                                 "release", "version")], collapse = " "), 
[01:29:31.877]                               hostname = base::Sys.info()[["nodename"]])
[01:29:31.877]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:31.877]                               info)
[01:29:31.877]                             info <- base::paste(info, collapse = "; ")
[01:29:31.877]                             if (!has_future) {
[01:29:31.877]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:31.877]                                 info)
[01:29:31.877]                             }
[01:29:31.877]                             else {
[01:29:31.877]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:31.877]                                 info, version)
[01:29:31.877]                             }
[01:29:31.877]                             base::stop(msg)
[01:29:31.877]                           }
[01:29:31.877]                         })
[01:29:31.877]                       }
[01:29:31.877]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:31.877]                       base::options(mc.cores = 1L)
[01:29:31.877]                     }
[01:29:31.877]                     options(future.plan = NULL)
[01:29:31.877]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.877]                     future::plan("default", .cleanup = FALSE, 
[01:29:31.877]                       .init = FALSE)
[01:29:31.877]                   }
[01:29:31.877]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[01:29:31.877]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[01:29:31.877]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[01:29:31.877]                 }
[01:29:31.877]                 ...future.workdir <- getwd()
[01:29:31.877]             }
[01:29:31.877]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:31.877]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:31.877]         }
[01:29:31.877]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:31.877]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:31.877]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:31.877]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:31.877]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:31.877]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:31.877]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:31.877]             base::names(...future.oldOptions))
[01:29:31.877]     }
[01:29:31.877]     if (FALSE) {
[01:29:31.877]     }
[01:29:31.877]     else {
[01:29:31.877]         if (TRUE) {
[01:29:31.877]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:31.877]                 open = "w")
[01:29:31.877]         }
[01:29:31.877]         else {
[01:29:31.877]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:31.877]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:31.877]         }
[01:29:31.877]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:31.877]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:31.877]             base::sink(type = "output", split = FALSE)
[01:29:31.877]             base::close(...future.stdout)
[01:29:31.877]         }, add = TRUE)
[01:29:31.877]     }
[01:29:31.877]     ...future.frame <- base::sys.nframe()
[01:29:31.877]     ...future.conditions <- base::list()
[01:29:31.877]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:31.877]     if (FALSE) {
[01:29:31.877]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:31.877]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:31.877]     }
[01:29:31.877]     ...future.result <- base::tryCatch({
[01:29:31.877]         base::withCallingHandlers({
[01:29:31.877]             ...future.value <- base::withVisible(base::local({
[01:29:31.877]                 ...future.makeSendCondition <- base::local({
[01:29:31.877]                   sendCondition <- NULL
[01:29:31.877]                   function(frame = 1L) {
[01:29:31.877]                     if (is.function(sendCondition)) 
[01:29:31.877]                       return(sendCondition)
[01:29:31.877]                     ns <- getNamespace("parallel")
[01:29:31.877]                     if (exists("sendData", mode = "function", 
[01:29:31.877]                       envir = ns)) {
[01:29:31.877]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:31.877]                         envir = ns)
[01:29:31.877]                       envir <- sys.frame(frame)
[01:29:31.877]                       master <- NULL
[01:29:31.877]                       while (!identical(envir, .GlobalEnv) && 
[01:29:31.877]                         !identical(envir, emptyenv())) {
[01:29:31.877]                         if (exists("master", mode = "list", envir = envir, 
[01:29:31.877]                           inherits = FALSE)) {
[01:29:31.877]                           master <- get("master", mode = "list", 
[01:29:31.877]                             envir = envir, inherits = FALSE)
[01:29:31.877]                           if (inherits(master, c("SOCKnode", 
[01:29:31.877]                             "SOCK0node"))) {
[01:29:31.877]                             sendCondition <<- function(cond) {
[01:29:31.877]                               data <- list(type = "VALUE", value = cond, 
[01:29:31.877]                                 success = TRUE)
[01:29:31.877]                               parallel_sendData(master, data)
[01:29:31.877]                             }
[01:29:31.877]                             return(sendCondition)
[01:29:31.877]                           }
[01:29:31.877]                         }
[01:29:31.877]                         frame <- frame + 1L
[01:29:31.877]                         envir <- sys.frame(frame)
[01:29:31.877]                       }
[01:29:31.877]                     }
[01:29:31.877]                     sendCondition <<- function(cond) NULL
[01:29:31.877]                   }
[01:29:31.877]                 })
[01:29:31.877]                 withCallingHandlers({
[01:29:31.877]                   {
[01:29:31.877]                     sample(x, size = 1L)
[01:29:31.877]                   }
[01:29:31.877]                 }, immediateCondition = function(cond) {
[01:29:31.877]                   sendCondition <- ...future.makeSendCondition()
[01:29:31.877]                   sendCondition(cond)
[01:29:31.877]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.877]                   {
[01:29:31.877]                     inherits <- base::inherits
[01:29:31.877]                     invokeRestart <- base::invokeRestart
[01:29:31.877]                     is.null <- base::is.null
[01:29:31.877]                     muffled <- FALSE
[01:29:31.877]                     if (inherits(cond, "message")) {
[01:29:31.877]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:31.877]                       if (muffled) 
[01:29:31.877]                         invokeRestart("muffleMessage")
[01:29:31.877]                     }
[01:29:31.877]                     else if (inherits(cond, "warning")) {
[01:29:31.877]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:31.877]                       if (muffled) 
[01:29:31.877]                         invokeRestart("muffleWarning")
[01:29:31.877]                     }
[01:29:31.877]                     else if (inherits(cond, "condition")) {
[01:29:31.877]                       if (!is.null(pattern)) {
[01:29:31.877]                         computeRestarts <- base::computeRestarts
[01:29:31.877]                         grepl <- base::grepl
[01:29:31.877]                         restarts <- computeRestarts(cond)
[01:29:31.877]                         for (restart in restarts) {
[01:29:31.877]                           name <- restart$name
[01:29:31.877]                           if (is.null(name)) 
[01:29:31.877]                             next
[01:29:31.877]                           if (!grepl(pattern, name)) 
[01:29:31.877]                             next
[01:29:31.877]                           invokeRestart(restart)
[01:29:31.877]                           muffled <- TRUE
[01:29:31.877]                           break
[01:29:31.877]                         }
[01:29:31.877]                       }
[01:29:31.877]                     }
[01:29:31.877]                     invisible(muffled)
[01:29:31.877]                   }
[01:29:31.877]                   muffleCondition(cond)
[01:29:31.877]                 })
[01:29:31.877]             }))
[01:29:31.877]             future::FutureResult(value = ...future.value$value, 
[01:29:31.877]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.877]                   ...future.rng), globalenv = if (FALSE) 
[01:29:31.877]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:31.877]                     ...future.globalenv.names))
[01:29:31.877]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:31.877]         }, condition = base::local({
[01:29:31.877]             c <- base::c
[01:29:31.877]             inherits <- base::inherits
[01:29:31.877]             invokeRestart <- base::invokeRestart
[01:29:31.877]             length <- base::length
[01:29:31.877]             list <- base::list
[01:29:31.877]             seq.int <- base::seq.int
[01:29:31.877]             signalCondition <- base::signalCondition
[01:29:31.877]             sys.calls <- base::sys.calls
[01:29:31.877]             `[[` <- base::`[[`
[01:29:31.877]             `+` <- base::`+`
[01:29:31.877]             `<<-` <- base::`<<-`
[01:29:31.877]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:31.877]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:31.877]                   3L)]
[01:29:31.877]             }
[01:29:31.877]             function(cond) {
[01:29:31.877]                 is_error <- inherits(cond, "error")
[01:29:31.877]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:31.877]                   NULL)
[01:29:31.877]                 if (is_error) {
[01:29:31.877]                   sessionInformation <- function() {
[01:29:31.877]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:31.877]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:31.877]                       search = base::search(), system = base::Sys.info())
[01:29:31.877]                   }
[01:29:31.877]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.877]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:31.877]                     cond$call), session = sessionInformation(), 
[01:29:31.877]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:31.877]                   signalCondition(cond)
[01:29:31.877]                 }
[01:29:31.877]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:31.877]                 "immediateCondition"))) {
[01:29:31.877]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:31.877]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.877]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:31.877]                   if (TRUE && !signal) {
[01:29:31.877]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.877]                     {
[01:29:31.877]                       inherits <- base::inherits
[01:29:31.877]                       invokeRestart <- base::invokeRestart
[01:29:31.877]                       is.null <- base::is.null
[01:29:31.877]                       muffled <- FALSE
[01:29:31.877]                       if (inherits(cond, "message")) {
[01:29:31.877]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.877]                         if (muffled) 
[01:29:31.877]                           invokeRestart("muffleMessage")
[01:29:31.877]                       }
[01:29:31.877]                       else if (inherits(cond, "warning")) {
[01:29:31.877]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.877]                         if (muffled) 
[01:29:31.877]                           invokeRestart("muffleWarning")
[01:29:31.877]                       }
[01:29:31.877]                       else if (inherits(cond, "condition")) {
[01:29:31.877]                         if (!is.null(pattern)) {
[01:29:31.877]                           computeRestarts <- base::computeRestarts
[01:29:31.877]                           grepl <- base::grepl
[01:29:31.877]                           restarts <- computeRestarts(cond)
[01:29:31.877]                           for (restart in restarts) {
[01:29:31.877]                             name <- restart$name
[01:29:31.877]                             if (is.null(name)) 
[01:29:31.877]                               next
[01:29:31.877]                             if (!grepl(pattern, name)) 
[01:29:31.877]                               next
[01:29:31.877]                             invokeRestart(restart)
[01:29:31.877]                             muffled <- TRUE
[01:29:31.877]                             break
[01:29:31.877]                           }
[01:29:31.877]                         }
[01:29:31.877]                       }
[01:29:31.877]                       invisible(muffled)
[01:29:31.877]                     }
[01:29:31.877]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.877]                   }
[01:29:31.877]                 }
[01:29:31.877]                 else {
[01:29:31.877]                   if (TRUE) {
[01:29:31.877]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.877]                     {
[01:29:31.877]                       inherits <- base::inherits
[01:29:31.877]                       invokeRestart <- base::invokeRestart
[01:29:31.877]                       is.null <- base::is.null
[01:29:31.877]                       muffled <- FALSE
[01:29:31.877]                       if (inherits(cond, "message")) {
[01:29:31.877]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.877]                         if (muffled) 
[01:29:31.877]                           invokeRestart("muffleMessage")
[01:29:31.877]                       }
[01:29:31.877]                       else if (inherits(cond, "warning")) {
[01:29:31.877]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.877]                         if (muffled) 
[01:29:31.877]                           invokeRestart("muffleWarning")
[01:29:31.877]                       }
[01:29:31.877]                       else if (inherits(cond, "condition")) {
[01:29:31.877]                         if (!is.null(pattern)) {
[01:29:31.877]                           computeRestarts <- base::computeRestarts
[01:29:31.877]                           grepl <- base::grepl
[01:29:31.877]                           restarts <- computeRestarts(cond)
[01:29:31.877]                           for (restart in restarts) {
[01:29:31.877]                             name <- restart$name
[01:29:31.877]                             if (is.null(name)) 
[01:29:31.877]                               next
[01:29:31.877]                             if (!grepl(pattern, name)) 
[01:29:31.877]                               next
[01:29:31.877]                             invokeRestart(restart)
[01:29:31.877]                             muffled <- TRUE
[01:29:31.877]                             break
[01:29:31.877]                           }
[01:29:31.877]                         }
[01:29:31.877]                       }
[01:29:31.877]                       invisible(muffled)
[01:29:31.877]                     }
[01:29:31.877]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.877]                   }
[01:29:31.877]                 }
[01:29:31.877]             }
[01:29:31.877]         }))
[01:29:31.877]     }, error = function(ex) {
[01:29:31.877]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:31.877]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.877]                 ...future.rng), started = ...future.startTime, 
[01:29:31.877]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:31.877]             version = "1.8"), class = "FutureResult")
[01:29:31.877]     }, finally = {
[01:29:31.877]         if (!identical(...future.workdir, getwd())) 
[01:29:31.877]             setwd(...future.workdir)
[01:29:31.877]         {
[01:29:31.877]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:31.877]                 ...future.oldOptions$nwarnings <- NULL
[01:29:31.877]             }
[01:29:31.877]             base::options(...future.oldOptions)
[01:29:31.877]             if (.Platform$OS.type == "windows") {
[01:29:31.877]                 old_names <- names(...future.oldEnvVars)
[01:29:31.877]                 envs <- base::Sys.getenv()
[01:29:31.877]                 names <- names(envs)
[01:29:31.877]                 common <- intersect(names, old_names)
[01:29:31.877]                 added <- setdiff(names, old_names)
[01:29:31.877]                 removed <- setdiff(old_names, names)
[01:29:31.877]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:31.877]                   envs[common]]
[01:29:31.877]                 NAMES <- toupper(changed)
[01:29:31.877]                 args <- list()
[01:29:31.877]                 for (kk in seq_along(NAMES)) {
[01:29:31.877]                   name <- changed[[kk]]
[01:29:31.877]                   NAME <- NAMES[[kk]]
[01:29:31.877]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.877]                     next
[01:29:31.877]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.877]                 }
[01:29:31.877]                 NAMES <- toupper(added)
[01:29:31.877]                 for (kk in seq_along(NAMES)) {
[01:29:31.877]                   name <- added[[kk]]
[01:29:31.877]                   NAME <- NAMES[[kk]]
[01:29:31.877]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.877]                     next
[01:29:31.877]                   args[[name]] <- ""
[01:29:31.877]                 }
[01:29:31.877]                 NAMES <- toupper(removed)
[01:29:31.877]                 for (kk in seq_along(NAMES)) {
[01:29:31.877]                   name <- removed[[kk]]
[01:29:31.877]                   NAME <- NAMES[[kk]]
[01:29:31.877]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.877]                     next
[01:29:31.877]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.877]                 }
[01:29:31.877]                 if (length(args) > 0) 
[01:29:31.877]                   base::do.call(base::Sys.setenv, args = args)
[01:29:31.877]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:31.877]             }
[01:29:31.877]             else {
[01:29:31.877]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:31.877]             }
[01:29:31.877]             {
[01:29:31.877]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:31.877]                   0L) {
[01:29:31.877]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:31.877]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:31.877]                   base::options(opts)
[01:29:31.877]                 }
[01:29:31.877]                 {
[01:29:31.877]                   {
[01:29:31.877]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:31.877]                     NULL
[01:29:31.877]                   }
[01:29:31.877]                   options(future.plan = NULL)
[01:29:31.877]                   if (is.na(NA_character_)) 
[01:29:31.877]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.877]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:31.877]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:31.877]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:31.877]                     envir = parent.frame()) 
[01:29:31.877]                   {
[01:29:31.877]                     if (is.function(workers)) 
[01:29:31.877]                       workers <- workers()
[01:29:31.877]                     workers <- structure(as.integer(workers), 
[01:29:31.877]                       class = class(workers))
[01:29:31.877]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:31.877]                       workers >= 1)
[01:29:31.877]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:31.877]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:31.877]                     }
[01:29:31.877]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:31.877]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:31.877]                       envir = envir)
[01:29:31.877]                     if (!future$lazy) 
[01:29:31.877]                       future <- run(future)
[01:29:31.877]                     invisible(future)
[01:29:31.877]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:31.877]                 }
[01:29:31.877]             }
[01:29:31.877]         }
[01:29:31.877]     })
[01:29:31.877]     if (TRUE) {
[01:29:31.877]         base::sink(type = "output", split = FALSE)
[01:29:31.877]         if (TRUE) {
[01:29:31.877]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:31.877]         }
[01:29:31.877]         else {
[01:29:31.877]             ...future.result["stdout"] <- base::list(NULL)
[01:29:31.877]         }
[01:29:31.877]         base::close(...future.stdout)
[01:29:31.877]         ...future.stdout <- NULL
[01:29:31.877]     }
[01:29:31.877]     ...future.result$conditions <- ...future.conditions
[01:29:31.877]     ...future.result$finished <- base::Sys.time()
[01:29:31.877]     ...future.result
[01:29:31.877] }
[01:29:31.883] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:31.883] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:31.883] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:31.884] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:31.884] MultisessionFuture started
[01:29:31.884] - Launch lazy future ... done
[01:29:31.884] run() for 'MultisessionFuture' ... done
[01:29:31.885] getGlobalsAndPackages() ...
[01:29:31.885] Searching for globals...
[01:29:31.886] - globals found: [3] '{', 'sample', 'x'
[01:29:31.887] Searching for globals ... DONE
[01:29:31.887] Resolving globals: FALSE
[01:29:31.887] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:31.888] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:31.888] - globals: [1] 'x'
[01:29:31.888] 
[01:29:31.888] getGlobalsAndPackages() ... DONE
[01:29:31.889] run() for 'Future' ...
[01:29:31.889] - state: 'created'
[01:29:31.889] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:31.903] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.903] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:31.903]   - Field: 'node'
[01:29:31.904]   - Field: 'label'
[01:29:31.904]   - Field: 'local'
[01:29:31.904]   - Field: 'owner'
[01:29:31.904]   - Field: 'envir'
[01:29:31.904]   - Field: 'workers'
[01:29:31.905]   - Field: 'packages'
[01:29:31.905]   - Field: 'gc'
[01:29:31.905]   - Field: 'conditions'
[01:29:31.905]   - Field: 'persistent'
[01:29:31.905]   - Field: 'expr'
[01:29:31.905]   - Field: 'uuid'
[01:29:31.906]   - Field: 'seed'
[01:29:31.906]   - Field: 'version'
[01:29:31.906]   - Field: 'result'
[01:29:31.906]   - Field: 'asynchronous'
[01:29:31.906]   - Field: 'calls'
[01:29:31.907]   - Field: 'globals'
[01:29:31.907]   - Field: 'stdout'
[01:29:31.907]   - Field: 'earlySignal'
[01:29:31.907]   - Field: 'lazy'
[01:29:31.907]   - Field: 'state'
[01:29:31.907] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:31.908] - Launch lazy future ...
[01:29:31.908] Packages needed by the future expression (n = 0): <none>
[01:29:31.908] Packages needed by future strategies (n = 0): <none>
[01:29:31.909] {
[01:29:31.909]     {
[01:29:31.909]         {
[01:29:31.909]             ...future.startTime <- base::Sys.time()
[01:29:31.909]             {
[01:29:31.909]                 {
[01:29:31.909]                   {
[01:29:31.909]                     {
[01:29:31.909]                       {
[01:29:31.909]                         base::local({
[01:29:31.909]                           has_future <- base::requireNamespace("future", 
[01:29:31.909]                             quietly = TRUE)
[01:29:31.909]                           if (has_future) {
[01:29:31.909]                             ns <- base::getNamespace("future")
[01:29:31.909]                             version <- ns[[".package"]][["version"]]
[01:29:31.909]                             if (is.null(version)) 
[01:29:31.909]                               version <- utils::packageVersion("future")
[01:29:31.909]                           }
[01:29:31.909]                           else {
[01:29:31.909]                             version <- NULL
[01:29:31.909]                           }
[01:29:31.909]                           if (!has_future || version < "1.8.0") {
[01:29:31.909]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:31.909]                               "", base::R.version$version.string), 
[01:29:31.909]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:31.909]                                 base::R.version$platform, 8 * 
[01:29:31.909]                                   base::.Machine$sizeof.pointer), 
[01:29:31.909]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:31.909]                                 "release", "version")], collapse = " "), 
[01:29:31.909]                               hostname = base::Sys.info()[["nodename"]])
[01:29:31.909]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:31.909]                               info)
[01:29:31.909]                             info <- base::paste(info, collapse = "; ")
[01:29:31.909]                             if (!has_future) {
[01:29:31.909]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:31.909]                                 info)
[01:29:31.909]                             }
[01:29:31.909]                             else {
[01:29:31.909]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:31.909]                                 info, version)
[01:29:31.909]                             }
[01:29:31.909]                             base::stop(msg)
[01:29:31.909]                           }
[01:29:31.909]                         })
[01:29:31.909]                       }
[01:29:31.909]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:31.909]                       base::options(mc.cores = 1L)
[01:29:31.909]                     }
[01:29:31.909]                     options(future.plan = NULL)
[01:29:31.909]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.909]                     future::plan("default", .cleanup = FALSE, 
[01:29:31.909]                       .init = FALSE)
[01:29:31.909]                   }
[01:29:31.909]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[01:29:31.909]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[01:29:31.909]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[01:29:31.909]                 }
[01:29:31.909]                 ...future.workdir <- getwd()
[01:29:31.909]             }
[01:29:31.909]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:31.909]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:31.909]         }
[01:29:31.909]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:31.909]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:31.909]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:31.909]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:31.909]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:31.909]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:31.909]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:31.909]             base::names(...future.oldOptions))
[01:29:31.909]     }
[01:29:31.909]     if (FALSE) {
[01:29:31.909]     }
[01:29:31.909]     else {
[01:29:31.909]         if (TRUE) {
[01:29:31.909]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:31.909]                 open = "w")
[01:29:31.909]         }
[01:29:31.909]         else {
[01:29:31.909]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:31.909]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:31.909]         }
[01:29:31.909]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:31.909]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:31.909]             base::sink(type = "output", split = FALSE)
[01:29:31.909]             base::close(...future.stdout)
[01:29:31.909]         }, add = TRUE)
[01:29:31.909]     }
[01:29:31.909]     ...future.frame <- base::sys.nframe()
[01:29:31.909]     ...future.conditions <- base::list()
[01:29:31.909]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:31.909]     if (FALSE) {
[01:29:31.909]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:31.909]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:31.909]     }
[01:29:31.909]     ...future.result <- base::tryCatch({
[01:29:31.909]         base::withCallingHandlers({
[01:29:31.909]             ...future.value <- base::withVisible(base::local({
[01:29:31.909]                 ...future.makeSendCondition <- base::local({
[01:29:31.909]                   sendCondition <- NULL
[01:29:31.909]                   function(frame = 1L) {
[01:29:31.909]                     if (is.function(sendCondition)) 
[01:29:31.909]                       return(sendCondition)
[01:29:31.909]                     ns <- getNamespace("parallel")
[01:29:31.909]                     if (exists("sendData", mode = "function", 
[01:29:31.909]                       envir = ns)) {
[01:29:31.909]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:31.909]                         envir = ns)
[01:29:31.909]                       envir <- sys.frame(frame)
[01:29:31.909]                       master <- NULL
[01:29:31.909]                       while (!identical(envir, .GlobalEnv) && 
[01:29:31.909]                         !identical(envir, emptyenv())) {
[01:29:31.909]                         if (exists("master", mode = "list", envir = envir, 
[01:29:31.909]                           inherits = FALSE)) {
[01:29:31.909]                           master <- get("master", mode = "list", 
[01:29:31.909]                             envir = envir, inherits = FALSE)
[01:29:31.909]                           if (inherits(master, c("SOCKnode", 
[01:29:31.909]                             "SOCK0node"))) {
[01:29:31.909]                             sendCondition <<- function(cond) {
[01:29:31.909]                               data <- list(type = "VALUE", value = cond, 
[01:29:31.909]                                 success = TRUE)
[01:29:31.909]                               parallel_sendData(master, data)
[01:29:31.909]                             }
[01:29:31.909]                             return(sendCondition)
[01:29:31.909]                           }
[01:29:31.909]                         }
[01:29:31.909]                         frame <- frame + 1L
[01:29:31.909]                         envir <- sys.frame(frame)
[01:29:31.909]                       }
[01:29:31.909]                     }
[01:29:31.909]                     sendCondition <<- function(cond) NULL
[01:29:31.909]                   }
[01:29:31.909]                 })
[01:29:31.909]                 withCallingHandlers({
[01:29:31.909]                   {
[01:29:31.909]                     sample(x, size = 1L)
[01:29:31.909]                   }
[01:29:31.909]                 }, immediateCondition = function(cond) {
[01:29:31.909]                   sendCondition <- ...future.makeSendCondition()
[01:29:31.909]                   sendCondition(cond)
[01:29:31.909]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.909]                   {
[01:29:31.909]                     inherits <- base::inherits
[01:29:31.909]                     invokeRestart <- base::invokeRestart
[01:29:31.909]                     is.null <- base::is.null
[01:29:31.909]                     muffled <- FALSE
[01:29:31.909]                     if (inherits(cond, "message")) {
[01:29:31.909]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:31.909]                       if (muffled) 
[01:29:31.909]                         invokeRestart("muffleMessage")
[01:29:31.909]                     }
[01:29:31.909]                     else if (inherits(cond, "warning")) {
[01:29:31.909]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:31.909]                       if (muffled) 
[01:29:31.909]                         invokeRestart("muffleWarning")
[01:29:31.909]                     }
[01:29:31.909]                     else if (inherits(cond, "condition")) {
[01:29:31.909]                       if (!is.null(pattern)) {
[01:29:31.909]                         computeRestarts <- base::computeRestarts
[01:29:31.909]                         grepl <- base::grepl
[01:29:31.909]                         restarts <- computeRestarts(cond)
[01:29:31.909]                         for (restart in restarts) {
[01:29:31.909]                           name <- restart$name
[01:29:31.909]                           if (is.null(name)) 
[01:29:31.909]                             next
[01:29:31.909]                           if (!grepl(pattern, name)) 
[01:29:31.909]                             next
[01:29:31.909]                           invokeRestart(restart)
[01:29:31.909]                           muffled <- TRUE
[01:29:31.909]                           break
[01:29:31.909]                         }
[01:29:31.909]                       }
[01:29:31.909]                     }
[01:29:31.909]                     invisible(muffled)
[01:29:31.909]                   }
[01:29:31.909]                   muffleCondition(cond)
[01:29:31.909]                 })
[01:29:31.909]             }))
[01:29:31.909]             future::FutureResult(value = ...future.value$value, 
[01:29:31.909]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.909]                   ...future.rng), globalenv = if (FALSE) 
[01:29:31.909]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:31.909]                     ...future.globalenv.names))
[01:29:31.909]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:31.909]         }, condition = base::local({
[01:29:31.909]             c <- base::c
[01:29:31.909]             inherits <- base::inherits
[01:29:31.909]             invokeRestart <- base::invokeRestart
[01:29:31.909]             length <- base::length
[01:29:31.909]             list <- base::list
[01:29:31.909]             seq.int <- base::seq.int
[01:29:31.909]             signalCondition <- base::signalCondition
[01:29:31.909]             sys.calls <- base::sys.calls
[01:29:31.909]             `[[` <- base::`[[`
[01:29:31.909]             `+` <- base::`+`
[01:29:31.909]             `<<-` <- base::`<<-`
[01:29:31.909]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:31.909]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:31.909]                   3L)]
[01:29:31.909]             }
[01:29:31.909]             function(cond) {
[01:29:31.909]                 is_error <- inherits(cond, "error")
[01:29:31.909]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:31.909]                   NULL)
[01:29:31.909]                 if (is_error) {
[01:29:31.909]                   sessionInformation <- function() {
[01:29:31.909]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:31.909]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:31.909]                       search = base::search(), system = base::Sys.info())
[01:29:31.909]                   }
[01:29:31.909]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.909]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:31.909]                     cond$call), session = sessionInformation(), 
[01:29:31.909]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:31.909]                   signalCondition(cond)
[01:29:31.909]                 }
[01:29:31.909]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:31.909]                 "immediateCondition"))) {
[01:29:31.909]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:31.909]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.909]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:31.909]                   if (TRUE && !signal) {
[01:29:31.909]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.909]                     {
[01:29:31.909]                       inherits <- base::inherits
[01:29:31.909]                       invokeRestart <- base::invokeRestart
[01:29:31.909]                       is.null <- base::is.null
[01:29:31.909]                       muffled <- FALSE
[01:29:31.909]                       if (inherits(cond, "message")) {
[01:29:31.909]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.909]                         if (muffled) 
[01:29:31.909]                           invokeRestart("muffleMessage")
[01:29:31.909]                       }
[01:29:31.909]                       else if (inherits(cond, "warning")) {
[01:29:31.909]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.909]                         if (muffled) 
[01:29:31.909]                           invokeRestart("muffleWarning")
[01:29:31.909]                       }
[01:29:31.909]                       else if (inherits(cond, "condition")) {
[01:29:31.909]                         if (!is.null(pattern)) {
[01:29:31.909]                           computeRestarts <- base::computeRestarts
[01:29:31.909]                           grepl <- base::grepl
[01:29:31.909]                           restarts <- computeRestarts(cond)
[01:29:31.909]                           for (restart in restarts) {
[01:29:31.909]                             name <- restart$name
[01:29:31.909]                             if (is.null(name)) 
[01:29:31.909]                               next
[01:29:31.909]                             if (!grepl(pattern, name)) 
[01:29:31.909]                               next
[01:29:31.909]                             invokeRestart(restart)
[01:29:31.909]                             muffled <- TRUE
[01:29:31.909]                             break
[01:29:31.909]                           }
[01:29:31.909]                         }
[01:29:31.909]                       }
[01:29:31.909]                       invisible(muffled)
[01:29:31.909]                     }
[01:29:31.909]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.909]                   }
[01:29:31.909]                 }
[01:29:31.909]                 else {
[01:29:31.909]                   if (TRUE) {
[01:29:31.909]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.909]                     {
[01:29:31.909]                       inherits <- base::inherits
[01:29:31.909]                       invokeRestart <- base::invokeRestart
[01:29:31.909]                       is.null <- base::is.null
[01:29:31.909]                       muffled <- FALSE
[01:29:31.909]                       if (inherits(cond, "message")) {
[01:29:31.909]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.909]                         if (muffled) 
[01:29:31.909]                           invokeRestart("muffleMessage")
[01:29:31.909]                       }
[01:29:31.909]                       else if (inherits(cond, "warning")) {
[01:29:31.909]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.909]                         if (muffled) 
[01:29:31.909]                           invokeRestart("muffleWarning")
[01:29:31.909]                       }
[01:29:31.909]                       else if (inherits(cond, "condition")) {
[01:29:31.909]                         if (!is.null(pattern)) {
[01:29:31.909]                           computeRestarts <- base::computeRestarts
[01:29:31.909]                           grepl <- base::grepl
[01:29:31.909]                           restarts <- computeRestarts(cond)
[01:29:31.909]                           for (restart in restarts) {
[01:29:31.909]                             name <- restart$name
[01:29:31.909]                             if (is.null(name)) 
[01:29:31.909]                               next
[01:29:31.909]                             if (!grepl(pattern, name)) 
[01:29:31.909]                               next
[01:29:31.909]                             invokeRestart(restart)
[01:29:31.909]                             muffled <- TRUE
[01:29:31.909]                             break
[01:29:31.909]                           }
[01:29:31.909]                         }
[01:29:31.909]                       }
[01:29:31.909]                       invisible(muffled)
[01:29:31.909]                     }
[01:29:31.909]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.909]                   }
[01:29:31.909]                 }
[01:29:31.909]             }
[01:29:31.909]         }))
[01:29:31.909]     }, error = function(ex) {
[01:29:31.909]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:31.909]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.909]                 ...future.rng), started = ...future.startTime, 
[01:29:31.909]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:31.909]             version = "1.8"), class = "FutureResult")
[01:29:31.909]     }, finally = {
[01:29:31.909]         if (!identical(...future.workdir, getwd())) 
[01:29:31.909]             setwd(...future.workdir)
[01:29:31.909]         {
[01:29:31.909]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:31.909]                 ...future.oldOptions$nwarnings <- NULL
[01:29:31.909]             }
[01:29:31.909]             base::options(...future.oldOptions)
[01:29:31.909]             if (.Platform$OS.type == "windows") {
[01:29:31.909]                 old_names <- names(...future.oldEnvVars)
[01:29:31.909]                 envs <- base::Sys.getenv()
[01:29:31.909]                 names <- names(envs)
[01:29:31.909]                 common <- intersect(names, old_names)
[01:29:31.909]                 added <- setdiff(names, old_names)
[01:29:31.909]                 removed <- setdiff(old_names, names)
[01:29:31.909]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:31.909]                   envs[common]]
[01:29:31.909]                 NAMES <- toupper(changed)
[01:29:31.909]                 args <- list()
[01:29:31.909]                 for (kk in seq_along(NAMES)) {
[01:29:31.909]                   name <- changed[[kk]]
[01:29:31.909]                   NAME <- NAMES[[kk]]
[01:29:31.909]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.909]                     next
[01:29:31.909]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.909]                 }
[01:29:31.909]                 NAMES <- toupper(added)
[01:29:31.909]                 for (kk in seq_along(NAMES)) {
[01:29:31.909]                   name <- added[[kk]]
[01:29:31.909]                   NAME <- NAMES[[kk]]
[01:29:31.909]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.909]                     next
[01:29:31.909]                   args[[name]] <- ""
[01:29:31.909]                 }
[01:29:31.909]                 NAMES <- toupper(removed)
[01:29:31.909]                 for (kk in seq_along(NAMES)) {
[01:29:31.909]                   name <- removed[[kk]]
[01:29:31.909]                   NAME <- NAMES[[kk]]
[01:29:31.909]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.909]                     next
[01:29:31.909]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.909]                 }
[01:29:31.909]                 if (length(args) > 0) 
[01:29:31.909]                   base::do.call(base::Sys.setenv, args = args)
[01:29:31.909]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:31.909]             }
[01:29:31.909]             else {
[01:29:31.909]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:31.909]             }
[01:29:31.909]             {
[01:29:31.909]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:31.909]                   0L) {
[01:29:31.909]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:31.909]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:31.909]                   base::options(opts)
[01:29:31.909]                 }
[01:29:31.909]                 {
[01:29:31.909]                   {
[01:29:31.909]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:31.909]                     NULL
[01:29:31.909]                   }
[01:29:31.909]                   options(future.plan = NULL)
[01:29:31.909]                   if (is.na(NA_character_)) 
[01:29:31.909]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.909]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:31.909]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:31.909]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:31.909]                     envir = parent.frame()) 
[01:29:31.909]                   {
[01:29:31.909]                     if (is.function(workers)) 
[01:29:31.909]                       workers <- workers()
[01:29:31.909]                     workers <- structure(as.integer(workers), 
[01:29:31.909]                       class = class(workers))
[01:29:31.909]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:31.909]                       workers >= 1)
[01:29:31.909]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:31.909]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:31.909]                     }
[01:29:31.909]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:31.909]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:31.909]                       envir = envir)
[01:29:31.909]                     if (!future$lazy) 
[01:29:31.909]                       future <- run(future)
[01:29:31.909]                     invisible(future)
[01:29:31.909]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:31.909]                 }
[01:29:31.909]             }
[01:29:31.909]         }
[01:29:31.909]     })
[01:29:31.909]     if (TRUE) {
[01:29:31.909]         base::sink(type = "output", split = FALSE)
[01:29:31.909]         if (TRUE) {
[01:29:31.909]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:31.909]         }
[01:29:31.909]         else {
[01:29:31.909]             ...future.result["stdout"] <- base::list(NULL)
[01:29:31.909]         }
[01:29:31.909]         base::close(...future.stdout)
[01:29:31.909]         ...future.stdout <- NULL
[01:29:31.909]     }
[01:29:31.909]     ...future.result$conditions <- ...future.conditions
[01:29:31.909]     ...future.result$finished <- base::Sys.time()
[01:29:31.909]     ...future.result
[01:29:31.909] }
[01:29:31.914] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:31.940] receiveMessageFromWorker() for ClusterFuture ...
[01:29:31.940] - Validating connection of MultisessionFuture
[01:29:31.941] - received message: FutureResult
[01:29:31.941] - Received FutureResult
[01:29:31.941] - Erased future from FutureRegistry
[01:29:31.941] result() for ClusterFuture ...
[01:29:31.941] - result already collected: FutureResult
[01:29:31.942] result() for ClusterFuture ... done
[01:29:31.942] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:31.942] result() for ClusterFuture ...
[01:29:31.942] - result already collected: FutureResult
[01:29:31.942] result() for ClusterFuture ... done
[01:29:31.943] result() for ClusterFuture ...
[01:29:31.943] - result already collected: FutureResult
[01:29:31.943] result() for ClusterFuture ... done
[01:29:31.944] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:31.944] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:31.944] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:31.944] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:31.945] MultisessionFuture started
[01:29:31.945] - Launch lazy future ... done
[01:29:31.946] run() for 'MultisessionFuture' ... done
[01:29:31.946] getGlobalsAndPackages() ...
[01:29:31.946] Searching for globals...
[01:29:31.947] - globals found: [3] '{', 'sample', 'x'
[01:29:31.948] Searching for globals ... DONE
[01:29:31.948] Resolving globals: FALSE
[01:29:31.948] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:31.949] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:31.949] - globals: [1] 'x'
[01:29:31.949] 
[01:29:31.949] getGlobalsAndPackages() ... DONE
[01:29:31.950] run() for 'Future' ...
[01:29:31.950] - state: 'created'
[01:29:31.950] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:31.964] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:31.965] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:31.965]   - Field: 'node'
[01:29:31.965]   - Field: 'label'
[01:29:31.965]   - Field: 'local'
[01:29:31.965]   - Field: 'owner'
[01:29:31.966]   - Field: 'envir'
[01:29:31.966]   - Field: 'workers'
[01:29:31.966]   - Field: 'packages'
[01:29:31.966]   - Field: 'gc'
[01:29:31.966]   - Field: 'conditions'
[01:29:31.966]   - Field: 'persistent'
[01:29:31.967]   - Field: 'expr'
[01:29:31.967]   - Field: 'uuid'
[01:29:31.967]   - Field: 'seed'
[01:29:31.967]   - Field: 'version'
[01:29:31.967]   - Field: 'result'
[01:29:31.968]   - Field: 'asynchronous'
[01:29:31.968]   - Field: 'calls'
[01:29:31.968]   - Field: 'globals'
[01:29:31.968]   - Field: 'stdout'
[01:29:31.968]   - Field: 'earlySignal'
[01:29:31.968]   - Field: 'lazy'
[01:29:31.969]   - Field: 'state'
[01:29:31.969] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:31.969] - Launch lazy future ...
[01:29:31.969] Packages needed by the future expression (n = 0): <none>
[01:29:31.970] Packages needed by future strategies (n = 0): <none>
[01:29:31.970] {
[01:29:31.970]     {
[01:29:31.970]         {
[01:29:31.970]             ...future.startTime <- base::Sys.time()
[01:29:31.970]             {
[01:29:31.970]                 {
[01:29:31.970]                   {
[01:29:31.970]                     {
[01:29:31.970]                       {
[01:29:31.970]                         base::local({
[01:29:31.970]                           has_future <- base::requireNamespace("future", 
[01:29:31.970]                             quietly = TRUE)
[01:29:31.970]                           if (has_future) {
[01:29:31.970]                             ns <- base::getNamespace("future")
[01:29:31.970]                             version <- ns[[".package"]][["version"]]
[01:29:31.970]                             if (is.null(version)) 
[01:29:31.970]                               version <- utils::packageVersion("future")
[01:29:31.970]                           }
[01:29:31.970]                           else {
[01:29:31.970]                             version <- NULL
[01:29:31.970]                           }
[01:29:31.970]                           if (!has_future || version < "1.8.0") {
[01:29:31.970]                             info <- base::c(r_version = base::gsub("R version ", 
[01:29:31.970]                               "", base::R.version$version.string), 
[01:29:31.970]                               platform = base::sprintf("%s (%s-bit)", 
[01:29:31.970]                                 base::R.version$platform, 8 * 
[01:29:31.970]                                   base::.Machine$sizeof.pointer), 
[01:29:31.970]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:31.970]                                 "release", "version")], collapse = " "), 
[01:29:31.970]                               hostname = base::Sys.info()[["nodename"]])
[01:29:31.970]                             info <- base::sprintf("%s: %s", base::names(info), 
[01:29:31.970]                               info)
[01:29:31.970]                             info <- base::paste(info, collapse = "; ")
[01:29:31.970]                             if (!has_future) {
[01:29:31.970]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:31.970]                                 info)
[01:29:31.970]                             }
[01:29:31.970]                             else {
[01:29:31.970]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:31.970]                                 info, version)
[01:29:31.970]                             }
[01:29:31.970]                             base::stop(msg)
[01:29:31.970]                           }
[01:29:31.970]                         })
[01:29:31.970]                       }
[01:29:31.970]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:31.970]                       base::options(mc.cores = 1L)
[01:29:31.970]                     }
[01:29:31.970]                     options(future.plan = NULL)
[01:29:31.970]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.970]                     future::plan("default", .cleanup = FALSE, 
[01:29:31.970]                       .init = FALSE)
[01:29:31.970]                   }
[01:29:31.970]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[01:29:31.970]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[01:29:31.970]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[01:29:31.970]                 }
[01:29:31.970]                 ...future.workdir <- getwd()
[01:29:31.970]             }
[01:29:31.970]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:31.970]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:31.970]         }
[01:29:31.970]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:31.970]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:31.970]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:31.970]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:31.970]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:31.970]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:31.970]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:31.970]             base::names(...future.oldOptions))
[01:29:31.970]     }
[01:29:31.970]     if (FALSE) {
[01:29:31.970]     }
[01:29:31.970]     else {
[01:29:31.970]         if (TRUE) {
[01:29:31.970]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:31.970]                 open = "w")
[01:29:31.970]         }
[01:29:31.970]         else {
[01:29:31.970]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:31.970]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:31.970]         }
[01:29:31.970]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:31.970]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:31.970]             base::sink(type = "output", split = FALSE)
[01:29:31.970]             base::close(...future.stdout)
[01:29:31.970]         }, add = TRUE)
[01:29:31.970]     }
[01:29:31.970]     ...future.frame <- base::sys.nframe()
[01:29:31.970]     ...future.conditions <- base::list()
[01:29:31.970]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:31.970]     if (FALSE) {
[01:29:31.970]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:31.970]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:31.970]     }
[01:29:31.970]     ...future.result <- base::tryCatch({
[01:29:31.970]         base::withCallingHandlers({
[01:29:31.970]             ...future.value <- base::withVisible(base::local({
[01:29:31.970]                 ...future.makeSendCondition <- base::local({
[01:29:31.970]                   sendCondition <- NULL
[01:29:31.970]                   function(frame = 1L) {
[01:29:31.970]                     if (is.function(sendCondition)) 
[01:29:31.970]                       return(sendCondition)
[01:29:31.970]                     ns <- getNamespace("parallel")
[01:29:31.970]                     if (exists("sendData", mode = "function", 
[01:29:31.970]                       envir = ns)) {
[01:29:31.970]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:31.970]                         envir = ns)
[01:29:31.970]                       envir <- sys.frame(frame)
[01:29:31.970]                       master <- NULL
[01:29:31.970]                       while (!identical(envir, .GlobalEnv) && 
[01:29:31.970]                         !identical(envir, emptyenv())) {
[01:29:31.970]                         if (exists("master", mode = "list", envir = envir, 
[01:29:31.970]                           inherits = FALSE)) {
[01:29:31.970]                           master <- get("master", mode = "list", 
[01:29:31.970]                             envir = envir, inherits = FALSE)
[01:29:31.970]                           if (inherits(master, c("SOCKnode", 
[01:29:31.970]                             "SOCK0node"))) {
[01:29:31.970]                             sendCondition <<- function(cond) {
[01:29:31.970]                               data <- list(type = "VALUE", value = cond, 
[01:29:31.970]                                 success = TRUE)
[01:29:31.970]                               parallel_sendData(master, data)
[01:29:31.970]                             }
[01:29:31.970]                             return(sendCondition)
[01:29:31.970]                           }
[01:29:31.970]                         }
[01:29:31.970]                         frame <- frame + 1L
[01:29:31.970]                         envir <- sys.frame(frame)
[01:29:31.970]                       }
[01:29:31.970]                     }
[01:29:31.970]                     sendCondition <<- function(cond) NULL
[01:29:31.970]                   }
[01:29:31.970]                 })
[01:29:31.970]                 withCallingHandlers({
[01:29:31.970]                   {
[01:29:31.970]                     sample(x, size = 1L)
[01:29:31.970]                   }
[01:29:31.970]                 }, immediateCondition = function(cond) {
[01:29:31.970]                   sendCondition <- ...future.makeSendCondition()
[01:29:31.970]                   sendCondition(cond)
[01:29:31.970]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.970]                   {
[01:29:31.970]                     inherits <- base::inherits
[01:29:31.970]                     invokeRestart <- base::invokeRestart
[01:29:31.970]                     is.null <- base::is.null
[01:29:31.970]                     muffled <- FALSE
[01:29:31.970]                     if (inherits(cond, "message")) {
[01:29:31.970]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:31.970]                       if (muffled) 
[01:29:31.970]                         invokeRestart("muffleMessage")
[01:29:31.970]                     }
[01:29:31.970]                     else if (inherits(cond, "warning")) {
[01:29:31.970]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:31.970]                       if (muffled) 
[01:29:31.970]                         invokeRestart("muffleWarning")
[01:29:31.970]                     }
[01:29:31.970]                     else if (inherits(cond, "condition")) {
[01:29:31.970]                       if (!is.null(pattern)) {
[01:29:31.970]                         computeRestarts <- base::computeRestarts
[01:29:31.970]                         grepl <- base::grepl
[01:29:31.970]                         restarts <- computeRestarts(cond)
[01:29:31.970]                         for (restart in restarts) {
[01:29:31.970]                           name <- restart$name
[01:29:31.970]                           if (is.null(name)) 
[01:29:31.970]                             next
[01:29:31.970]                           if (!grepl(pattern, name)) 
[01:29:31.970]                             next
[01:29:31.970]                           invokeRestart(restart)
[01:29:31.970]                           muffled <- TRUE
[01:29:31.970]                           break
[01:29:31.970]                         }
[01:29:31.970]                       }
[01:29:31.970]                     }
[01:29:31.970]                     invisible(muffled)
[01:29:31.970]                   }
[01:29:31.970]                   muffleCondition(cond)
[01:29:31.970]                 })
[01:29:31.970]             }))
[01:29:31.970]             future::FutureResult(value = ...future.value$value, 
[01:29:31.970]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.970]                   ...future.rng), globalenv = if (FALSE) 
[01:29:31.970]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:31.970]                     ...future.globalenv.names))
[01:29:31.970]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:31.970]         }, condition = base::local({
[01:29:31.970]             c <- base::c
[01:29:31.970]             inherits <- base::inherits
[01:29:31.970]             invokeRestart <- base::invokeRestart
[01:29:31.970]             length <- base::length
[01:29:31.970]             list <- base::list
[01:29:31.970]             seq.int <- base::seq.int
[01:29:31.970]             signalCondition <- base::signalCondition
[01:29:31.970]             sys.calls <- base::sys.calls
[01:29:31.970]             `[[` <- base::`[[`
[01:29:31.970]             `+` <- base::`+`
[01:29:31.970]             `<<-` <- base::`<<-`
[01:29:31.970]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:31.970]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:31.970]                   3L)]
[01:29:31.970]             }
[01:29:31.970]             function(cond) {
[01:29:31.970]                 is_error <- inherits(cond, "error")
[01:29:31.970]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:31.970]                   NULL)
[01:29:31.970]                 if (is_error) {
[01:29:31.970]                   sessionInformation <- function() {
[01:29:31.970]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:31.970]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:31.970]                       search = base::search(), system = base::Sys.info())
[01:29:31.970]                   }
[01:29:31.970]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.970]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:31.970]                     cond$call), session = sessionInformation(), 
[01:29:31.970]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:31.970]                   signalCondition(cond)
[01:29:31.970]                 }
[01:29:31.970]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:31.970]                 "immediateCondition"))) {
[01:29:31.970]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:31.970]                   ...future.conditions[[length(...future.conditions) + 
[01:29:31.970]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:31.970]                   if (TRUE && !signal) {
[01:29:31.970]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.970]                     {
[01:29:31.970]                       inherits <- base::inherits
[01:29:31.970]                       invokeRestart <- base::invokeRestart
[01:29:31.970]                       is.null <- base::is.null
[01:29:31.970]                       muffled <- FALSE
[01:29:31.970]                       if (inherits(cond, "message")) {
[01:29:31.970]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.970]                         if (muffled) 
[01:29:31.970]                           invokeRestart("muffleMessage")
[01:29:31.970]                       }
[01:29:31.970]                       else if (inherits(cond, "warning")) {
[01:29:31.970]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.970]                         if (muffled) 
[01:29:31.970]                           invokeRestart("muffleWarning")
[01:29:31.970]                       }
[01:29:31.970]                       else if (inherits(cond, "condition")) {
[01:29:31.970]                         if (!is.null(pattern)) {
[01:29:31.970]                           computeRestarts <- base::computeRestarts
[01:29:31.970]                           grepl <- base::grepl
[01:29:31.970]                           restarts <- computeRestarts(cond)
[01:29:31.970]                           for (restart in restarts) {
[01:29:31.970]                             name <- restart$name
[01:29:31.970]                             if (is.null(name)) 
[01:29:31.970]                               next
[01:29:31.970]                             if (!grepl(pattern, name)) 
[01:29:31.970]                               next
[01:29:31.970]                             invokeRestart(restart)
[01:29:31.970]                             muffled <- TRUE
[01:29:31.970]                             break
[01:29:31.970]                           }
[01:29:31.970]                         }
[01:29:31.970]                       }
[01:29:31.970]                       invisible(muffled)
[01:29:31.970]                     }
[01:29:31.970]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.970]                   }
[01:29:31.970]                 }
[01:29:31.970]                 else {
[01:29:31.970]                   if (TRUE) {
[01:29:31.970]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:31.970]                     {
[01:29:31.970]                       inherits <- base::inherits
[01:29:31.970]                       invokeRestart <- base::invokeRestart
[01:29:31.970]                       is.null <- base::is.null
[01:29:31.970]                       muffled <- FALSE
[01:29:31.970]                       if (inherits(cond, "message")) {
[01:29:31.970]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:31.970]                         if (muffled) 
[01:29:31.970]                           invokeRestart("muffleMessage")
[01:29:31.970]                       }
[01:29:31.970]                       else if (inherits(cond, "warning")) {
[01:29:31.970]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:31.970]                         if (muffled) 
[01:29:31.970]                           invokeRestart("muffleWarning")
[01:29:31.970]                       }
[01:29:31.970]                       else if (inherits(cond, "condition")) {
[01:29:31.970]                         if (!is.null(pattern)) {
[01:29:31.970]                           computeRestarts <- base::computeRestarts
[01:29:31.970]                           grepl <- base::grepl
[01:29:31.970]                           restarts <- computeRestarts(cond)
[01:29:31.970]                           for (restart in restarts) {
[01:29:31.970]                             name <- restart$name
[01:29:31.970]                             if (is.null(name)) 
[01:29:31.970]                               next
[01:29:31.970]                             if (!grepl(pattern, name)) 
[01:29:31.970]                               next
[01:29:31.970]                             invokeRestart(restart)
[01:29:31.970]                             muffled <- TRUE
[01:29:31.970]                             break
[01:29:31.970]                           }
[01:29:31.970]                         }
[01:29:31.970]                       }
[01:29:31.970]                       invisible(muffled)
[01:29:31.970]                     }
[01:29:31.970]                     muffleCondition(cond, pattern = "^muffle")
[01:29:31.970]                   }
[01:29:31.970]                 }
[01:29:31.970]             }
[01:29:31.970]         }))
[01:29:31.970]     }, error = function(ex) {
[01:29:31.970]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:31.970]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:31.970]                 ...future.rng), started = ...future.startTime, 
[01:29:31.970]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:31.970]             version = "1.8"), class = "FutureResult")
[01:29:31.970]     }, finally = {
[01:29:31.970]         if (!identical(...future.workdir, getwd())) 
[01:29:31.970]             setwd(...future.workdir)
[01:29:31.970]         {
[01:29:31.970]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:31.970]                 ...future.oldOptions$nwarnings <- NULL
[01:29:31.970]             }
[01:29:31.970]             base::options(...future.oldOptions)
[01:29:31.970]             if (.Platform$OS.type == "windows") {
[01:29:31.970]                 old_names <- names(...future.oldEnvVars)
[01:29:31.970]                 envs <- base::Sys.getenv()
[01:29:31.970]                 names <- names(envs)
[01:29:31.970]                 common <- intersect(names, old_names)
[01:29:31.970]                 added <- setdiff(names, old_names)
[01:29:31.970]                 removed <- setdiff(old_names, names)
[01:29:31.970]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:31.970]                   envs[common]]
[01:29:31.970]                 NAMES <- toupper(changed)
[01:29:31.970]                 args <- list()
[01:29:31.970]                 for (kk in seq_along(NAMES)) {
[01:29:31.970]                   name <- changed[[kk]]
[01:29:31.970]                   NAME <- NAMES[[kk]]
[01:29:31.970]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.970]                     next
[01:29:31.970]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.970]                 }
[01:29:31.970]                 NAMES <- toupper(added)
[01:29:31.970]                 for (kk in seq_along(NAMES)) {
[01:29:31.970]                   name <- added[[kk]]
[01:29:31.970]                   NAME <- NAMES[[kk]]
[01:29:31.970]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.970]                     next
[01:29:31.970]                   args[[name]] <- ""
[01:29:31.970]                 }
[01:29:31.970]                 NAMES <- toupper(removed)
[01:29:31.970]                 for (kk in seq_along(NAMES)) {
[01:29:31.970]                   name <- removed[[kk]]
[01:29:31.970]                   NAME <- NAMES[[kk]]
[01:29:31.970]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:31.970]                     next
[01:29:31.970]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:31.970]                 }
[01:29:31.970]                 if (length(args) > 0) 
[01:29:31.970]                   base::do.call(base::Sys.setenv, args = args)
[01:29:31.970]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:31.970]             }
[01:29:31.970]             else {
[01:29:31.970]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:31.970]             }
[01:29:31.970]             {
[01:29:31.970]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:31.970]                   0L) {
[01:29:31.970]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:31.970]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:31.970]                   base::options(opts)
[01:29:31.970]                 }
[01:29:31.970]                 {
[01:29:31.970]                   {
[01:29:31.970]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:31.970]                     NULL
[01:29:31.970]                   }
[01:29:31.970]                   options(future.plan = NULL)
[01:29:31.970]                   if (is.na(NA_character_)) 
[01:29:31.970]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:31.970]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:31.970]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:31.970]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:31.970]                     envir = parent.frame()) 
[01:29:31.970]                   {
[01:29:31.970]                     if (is.function(workers)) 
[01:29:31.970]                       workers <- workers()
[01:29:31.970]                     workers <- structure(as.integer(workers), 
[01:29:31.970]                       class = class(workers))
[01:29:31.970]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:31.970]                       workers >= 1)
[01:29:31.970]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:31.970]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:31.970]                     }
[01:29:31.970]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:31.970]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:31.970]                       envir = envir)
[01:29:31.970]                     if (!future$lazy) 
[01:29:31.970]                       future <- run(future)
[01:29:31.970]                     invisible(future)
[01:29:31.970]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:31.970]                 }
[01:29:31.970]             }
[01:29:31.970]         }
[01:29:31.970]     })
[01:29:31.970]     if (TRUE) {
[01:29:31.970]         base::sink(type = "output", split = FALSE)
[01:29:31.970]         if (TRUE) {
[01:29:31.970]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:31.970]         }
[01:29:31.970]         else {
[01:29:31.970]             ...future.result["stdout"] <- base::list(NULL)
[01:29:31.970]         }
[01:29:31.970]         base::close(...future.stdout)
[01:29:31.970]         ...future.stdout <- NULL
[01:29:31.970]     }
[01:29:31.970]     ...future.result$conditions <- ...future.conditions
[01:29:31.970]     ...future.result$finished <- base::Sys.time()
[01:29:31.970]     ...future.result
[01:29:31.970] }
[01:29:31.975] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:31.987] receiveMessageFromWorker() for ClusterFuture ...
[01:29:31.987] - Validating connection of MultisessionFuture
[01:29:31.988] - received message: FutureResult
[01:29:31.988] - Received FutureResult
[01:29:31.988] - Erased future from FutureRegistry
[01:29:31.988] result() for ClusterFuture ...
[01:29:31.988] - result already collected: FutureResult
[01:29:31.989] result() for ClusterFuture ... done
[01:29:31.989] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:31.989] result() for ClusterFuture ...
[01:29:31.989] - result already collected: FutureResult
[01:29:31.989] result() for ClusterFuture ... done
[01:29:31.990] result() for ClusterFuture ...
[01:29:31.990] - result already collected: FutureResult
[01:29:32.002] result() for ClusterFuture ... done
[01:29:32.003] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:32.003] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:32.004] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:32.004] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:32.005] MultisessionFuture started
[01:29:32.005] - Launch lazy future ... done
[01:29:32.005] run() for 'MultisessionFuture' ... done
[01:29:32.005] result() for ClusterFuture ...
[01:29:32.006] - result already collected: FutureResult
[01:29:32.006] result() for ClusterFuture ... done
[01:29:32.006] result() for ClusterFuture ...
[01:29:32.006] - result already collected: FutureResult
[01:29:32.006] result() for ClusterFuture ... done
[01:29:32.006] result() for ClusterFuture ...
[01:29:32.007] - result already collected: FutureResult
[01:29:32.007] result() for ClusterFuture ... done
[01:29:32.007] result() for ClusterFuture ...
[01:29:32.007] - result already collected: FutureResult
[01:29:32.007] result() for ClusterFuture ... done
[01:29:32.007] result() for ClusterFuture ...
[01:29:32.008] receiveMessageFromWorker() for ClusterFuture ...
[01:29:32.008] - Validating connection of MultisessionFuture
[01:29:32.008] - received message: FutureResult
[01:29:32.008] - Received FutureResult
[01:29:32.008] - Erased future from FutureRegistry
[01:29:32.009] result() for ClusterFuture ...
[01:29:32.009] - result already collected: FutureResult
[01:29:32.009] result() for ClusterFuture ... done
[01:29:32.009] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:32.009] result() for ClusterFuture ... done
[01:29:32.009] result() for ClusterFuture ...
[01:29:32.010] - result already collected: FutureResult
[01:29:32.010] result() for ClusterFuture ... done
[01:29:32.010] result() for ClusterFuture ...
[01:29:32.010] receiveMessageFromWorker() for ClusterFuture ...
[01:29:32.010] - Validating connection of MultisessionFuture
[01:29:32.022] - received message: FutureResult
[01:29:32.023] - Received FutureResult
[01:29:32.023] - Erased future from FutureRegistry
[01:29:32.023] result() for ClusterFuture ...
[01:29:32.023] - result already collected: FutureResult
[01:29:32.023] result() for ClusterFuture ... done
[01:29:32.024] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:32.024] result() for ClusterFuture ... done
[01:29:32.024] result() for ClusterFuture ...
[01:29:32.024] - result already collected: FutureResult
[01:29:32.024] result() for ClusterFuture ... done
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[01:29:32.025] getGlobalsAndPackages() ...
[01:29:32.025] Searching for globals...
[01:29:32.027] - globals found: [3] '{', 'sample', 'x'
[01:29:32.027] Searching for globals ... DONE
[01:29:32.027] Resolving globals: FALSE
[01:29:32.028] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:32.029] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:32.029] - globals: [1] 'x'
[01:29:32.029] 
[01:29:32.029] getGlobalsAndPackages() ... DONE
[01:29:32.030] run() for 'Future' ...
[01:29:32.030] - state: 'created'
[01:29:32.030] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:32.045] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:32.045] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:32.046]   - Field: 'node'
[01:29:32.046]   - Field: 'label'
[01:29:32.046]   - Field: 'local'
[01:29:32.046]   - Field: 'owner'
[01:29:32.046]   - Field: 'envir'
[01:29:32.046]   - Field: 'workers'
[01:29:32.047]   - Field: 'packages'
[01:29:32.047]   - Field: 'gc'
[01:29:32.047]   - Field: 'conditions'
[01:29:32.047]   - Field: 'persistent'
[01:29:32.047]   - Field: 'expr'
[01:29:32.048]   - Field: 'uuid'
[01:29:32.048]   - Field: 'seed'
[01:29:32.048]   - Field: 'version'
[01:29:32.048]   - Field: 'result'
[01:29:32.048]   - Field: 'asynchronous'
[01:29:32.048]   - Field: 'calls'
[01:29:32.049]   - Field: 'globals'
[01:29:32.049]   - Field: 'stdout'
[01:29:32.049]   - Field: 'earlySignal'
[01:29:32.049]   - Field: 'lazy'
[01:29:32.049]   - Field: 'state'
[01:29:32.050] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:32.050] - Launch lazy future ...
[01:29:32.050] Packages needed by the future expression (n = 0): <none>
[01:29:32.050] Packages needed by future strategies (n = 0): <none>
[01:29:32.051] {
[01:29:32.051]     {
[01:29:32.051]         {
[01:29:32.051]             ...future.startTime <- base::Sys.time()
[01:29:32.051]             {
[01:29:32.051]                 {
[01:29:32.051]                   {
[01:29:32.051]                     {
[01:29:32.051]                       base::local({
[01:29:32.051]                         has_future <- base::requireNamespace("future", 
[01:29:32.051]                           quietly = TRUE)
[01:29:32.051]                         if (has_future) {
[01:29:32.051]                           ns <- base::getNamespace("future")
[01:29:32.051]                           version <- ns[[".package"]][["version"]]
[01:29:32.051]                           if (is.null(version)) 
[01:29:32.051]                             version <- utils::packageVersion("future")
[01:29:32.051]                         }
[01:29:32.051]                         else {
[01:29:32.051]                           version <- NULL
[01:29:32.051]                         }
[01:29:32.051]                         if (!has_future || version < "1.8.0") {
[01:29:32.051]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:32.051]                             "", base::R.version$version.string), 
[01:29:32.051]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:32.051]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:32.051]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:32.051]                               "release", "version")], collapse = " "), 
[01:29:32.051]                             hostname = base::Sys.info()[["nodename"]])
[01:29:32.051]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:32.051]                             info)
[01:29:32.051]                           info <- base::paste(info, collapse = "; ")
[01:29:32.051]                           if (!has_future) {
[01:29:32.051]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:32.051]                               info)
[01:29:32.051]                           }
[01:29:32.051]                           else {
[01:29:32.051]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:32.051]                               info, version)
[01:29:32.051]                           }
[01:29:32.051]                           base::stop(msg)
[01:29:32.051]                         }
[01:29:32.051]                       })
[01:29:32.051]                     }
[01:29:32.051]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:32.051]                     base::options(mc.cores = 1L)
[01:29:32.051]                   }
[01:29:32.051]                   options(future.plan = NULL)
[01:29:32.051]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.051]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:32.051]                 }
[01:29:32.051]                 ...future.workdir <- getwd()
[01:29:32.051]             }
[01:29:32.051]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:32.051]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:32.051]         }
[01:29:32.051]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:32.051]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:32.051]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:32.051]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:32.051]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:32.051]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:32.051]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:32.051]             base::names(...future.oldOptions))
[01:29:32.051]     }
[01:29:32.051]     if (FALSE) {
[01:29:32.051]     }
[01:29:32.051]     else {
[01:29:32.051]         if (TRUE) {
[01:29:32.051]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:32.051]                 open = "w")
[01:29:32.051]         }
[01:29:32.051]         else {
[01:29:32.051]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:32.051]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:32.051]         }
[01:29:32.051]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:32.051]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:32.051]             base::sink(type = "output", split = FALSE)
[01:29:32.051]             base::close(...future.stdout)
[01:29:32.051]         }, add = TRUE)
[01:29:32.051]     }
[01:29:32.051]     ...future.frame <- base::sys.nframe()
[01:29:32.051]     ...future.conditions <- base::list()
[01:29:32.051]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:32.051]     if (FALSE) {
[01:29:32.051]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:32.051]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:32.051]     }
[01:29:32.051]     ...future.result <- base::tryCatch({
[01:29:32.051]         base::withCallingHandlers({
[01:29:32.051]             ...future.value <- base::withVisible(base::local({
[01:29:32.051]                 ...future.makeSendCondition <- base::local({
[01:29:32.051]                   sendCondition <- NULL
[01:29:32.051]                   function(frame = 1L) {
[01:29:32.051]                     if (is.function(sendCondition)) 
[01:29:32.051]                       return(sendCondition)
[01:29:32.051]                     ns <- getNamespace("parallel")
[01:29:32.051]                     if (exists("sendData", mode = "function", 
[01:29:32.051]                       envir = ns)) {
[01:29:32.051]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:32.051]                         envir = ns)
[01:29:32.051]                       envir <- sys.frame(frame)
[01:29:32.051]                       master <- NULL
[01:29:32.051]                       while (!identical(envir, .GlobalEnv) && 
[01:29:32.051]                         !identical(envir, emptyenv())) {
[01:29:32.051]                         if (exists("master", mode = "list", envir = envir, 
[01:29:32.051]                           inherits = FALSE)) {
[01:29:32.051]                           master <- get("master", mode = "list", 
[01:29:32.051]                             envir = envir, inherits = FALSE)
[01:29:32.051]                           if (inherits(master, c("SOCKnode", 
[01:29:32.051]                             "SOCK0node"))) {
[01:29:32.051]                             sendCondition <<- function(cond) {
[01:29:32.051]                               data <- list(type = "VALUE", value = cond, 
[01:29:32.051]                                 success = TRUE)
[01:29:32.051]                               parallel_sendData(master, data)
[01:29:32.051]                             }
[01:29:32.051]                             return(sendCondition)
[01:29:32.051]                           }
[01:29:32.051]                         }
[01:29:32.051]                         frame <- frame + 1L
[01:29:32.051]                         envir <- sys.frame(frame)
[01:29:32.051]                       }
[01:29:32.051]                     }
[01:29:32.051]                     sendCondition <<- function(cond) NULL
[01:29:32.051]                   }
[01:29:32.051]                 })
[01:29:32.051]                 withCallingHandlers({
[01:29:32.051]                   {
[01:29:32.051]                     sample(x, size = 1L)
[01:29:32.051]                   }
[01:29:32.051]                 }, immediateCondition = function(cond) {
[01:29:32.051]                   sendCondition <- ...future.makeSendCondition()
[01:29:32.051]                   sendCondition(cond)
[01:29:32.051]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.051]                   {
[01:29:32.051]                     inherits <- base::inherits
[01:29:32.051]                     invokeRestart <- base::invokeRestart
[01:29:32.051]                     is.null <- base::is.null
[01:29:32.051]                     muffled <- FALSE
[01:29:32.051]                     if (inherits(cond, "message")) {
[01:29:32.051]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:32.051]                       if (muffled) 
[01:29:32.051]                         invokeRestart("muffleMessage")
[01:29:32.051]                     }
[01:29:32.051]                     else if (inherits(cond, "warning")) {
[01:29:32.051]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:32.051]                       if (muffled) 
[01:29:32.051]                         invokeRestart("muffleWarning")
[01:29:32.051]                     }
[01:29:32.051]                     else if (inherits(cond, "condition")) {
[01:29:32.051]                       if (!is.null(pattern)) {
[01:29:32.051]                         computeRestarts <- base::computeRestarts
[01:29:32.051]                         grepl <- base::grepl
[01:29:32.051]                         restarts <- computeRestarts(cond)
[01:29:32.051]                         for (restart in restarts) {
[01:29:32.051]                           name <- restart$name
[01:29:32.051]                           if (is.null(name)) 
[01:29:32.051]                             next
[01:29:32.051]                           if (!grepl(pattern, name)) 
[01:29:32.051]                             next
[01:29:32.051]                           invokeRestart(restart)
[01:29:32.051]                           muffled <- TRUE
[01:29:32.051]                           break
[01:29:32.051]                         }
[01:29:32.051]                       }
[01:29:32.051]                     }
[01:29:32.051]                     invisible(muffled)
[01:29:32.051]                   }
[01:29:32.051]                   muffleCondition(cond)
[01:29:32.051]                 })
[01:29:32.051]             }))
[01:29:32.051]             future::FutureResult(value = ...future.value$value, 
[01:29:32.051]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.051]                   ...future.rng), globalenv = if (FALSE) 
[01:29:32.051]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:32.051]                     ...future.globalenv.names))
[01:29:32.051]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:32.051]         }, condition = base::local({
[01:29:32.051]             c <- base::c
[01:29:32.051]             inherits <- base::inherits
[01:29:32.051]             invokeRestart <- base::invokeRestart
[01:29:32.051]             length <- base::length
[01:29:32.051]             list <- base::list
[01:29:32.051]             seq.int <- base::seq.int
[01:29:32.051]             signalCondition <- base::signalCondition
[01:29:32.051]             sys.calls <- base::sys.calls
[01:29:32.051]             `[[` <- base::`[[`
[01:29:32.051]             `+` <- base::`+`
[01:29:32.051]             `<<-` <- base::`<<-`
[01:29:32.051]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:32.051]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:32.051]                   3L)]
[01:29:32.051]             }
[01:29:32.051]             function(cond) {
[01:29:32.051]                 is_error <- inherits(cond, "error")
[01:29:32.051]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:32.051]                   NULL)
[01:29:32.051]                 if (is_error) {
[01:29:32.051]                   sessionInformation <- function() {
[01:29:32.051]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:32.051]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:32.051]                       search = base::search(), system = base::Sys.info())
[01:29:32.051]                   }
[01:29:32.051]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.051]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:32.051]                     cond$call), session = sessionInformation(), 
[01:29:32.051]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:32.051]                   signalCondition(cond)
[01:29:32.051]                 }
[01:29:32.051]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:32.051]                 "immediateCondition"))) {
[01:29:32.051]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:32.051]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.051]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:32.051]                   if (TRUE && !signal) {
[01:29:32.051]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.051]                     {
[01:29:32.051]                       inherits <- base::inherits
[01:29:32.051]                       invokeRestart <- base::invokeRestart
[01:29:32.051]                       is.null <- base::is.null
[01:29:32.051]                       muffled <- FALSE
[01:29:32.051]                       if (inherits(cond, "message")) {
[01:29:32.051]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.051]                         if (muffled) 
[01:29:32.051]                           invokeRestart("muffleMessage")
[01:29:32.051]                       }
[01:29:32.051]                       else if (inherits(cond, "warning")) {
[01:29:32.051]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.051]                         if (muffled) 
[01:29:32.051]                           invokeRestart("muffleWarning")
[01:29:32.051]                       }
[01:29:32.051]                       else if (inherits(cond, "condition")) {
[01:29:32.051]                         if (!is.null(pattern)) {
[01:29:32.051]                           computeRestarts <- base::computeRestarts
[01:29:32.051]                           grepl <- base::grepl
[01:29:32.051]                           restarts <- computeRestarts(cond)
[01:29:32.051]                           for (restart in restarts) {
[01:29:32.051]                             name <- restart$name
[01:29:32.051]                             if (is.null(name)) 
[01:29:32.051]                               next
[01:29:32.051]                             if (!grepl(pattern, name)) 
[01:29:32.051]                               next
[01:29:32.051]                             invokeRestart(restart)
[01:29:32.051]                             muffled <- TRUE
[01:29:32.051]                             break
[01:29:32.051]                           }
[01:29:32.051]                         }
[01:29:32.051]                       }
[01:29:32.051]                       invisible(muffled)
[01:29:32.051]                     }
[01:29:32.051]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.051]                   }
[01:29:32.051]                 }
[01:29:32.051]                 else {
[01:29:32.051]                   if (TRUE) {
[01:29:32.051]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.051]                     {
[01:29:32.051]                       inherits <- base::inherits
[01:29:32.051]                       invokeRestart <- base::invokeRestart
[01:29:32.051]                       is.null <- base::is.null
[01:29:32.051]                       muffled <- FALSE
[01:29:32.051]                       if (inherits(cond, "message")) {
[01:29:32.051]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.051]                         if (muffled) 
[01:29:32.051]                           invokeRestart("muffleMessage")
[01:29:32.051]                       }
[01:29:32.051]                       else if (inherits(cond, "warning")) {
[01:29:32.051]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.051]                         if (muffled) 
[01:29:32.051]                           invokeRestart("muffleWarning")
[01:29:32.051]                       }
[01:29:32.051]                       else if (inherits(cond, "condition")) {
[01:29:32.051]                         if (!is.null(pattern)) {
[01:29:32.051]                           computeRestarts <- base::computeRestarts
[01:29:32.051]                           grepl <- base::grepl
[01:29:32.051]                           restarts <- computeRestarts(cond)
[01:29:32.051]                           for (restart in restarts) {
[01:29:32.051]                             name <- restart$name
[01:29:32.051]                             if (is.null(name)) 
[01:29:32.051]                               next
[01:29:32.051]                             if (!grepl(pattern, name)) 
[01:29:32.051]                               next
[01:29:32.051]                             invokeRestart(restart)
[01:29:32.051]                             muffled <- TRUE
[01:29:32.051]                             break
[01:29:32.051]                           }
[01:29:32.051]                         }
[01:29:32.051]                       }
[01:29:32.051]                       invisible(muffled)
[01:29:32.051]                     }
[01:29:32.051]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.051]                   }
[01:29:32.051]                 }
[01:29:32.051]             }
[01:29:32.051]         }))
[01:29:32.051]     }, error = function(ex) {
[01:29:32.051]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:32.051]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.051]                 ...future.rng), started = ...future.startTime, 
[01:29:32.051]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:32.051]             version = "1.8"), class = "FutureResult")
[01:29:32.051]     }, finally = {
[01:29:32.051]         if (!identical(...future.workdir, getwd())) 
[01:29:32.051]             setwd(...future.workdir)
[01:29:32.051]         {
[01:29:32.051]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:32.051]                 ...future.oldOptions$nwarnings <- NULL
[01:29:32.051]             }
[01:29:32.051]             base::options(...future.oldOptions)
[01:29:32.051]             if (.Platform$OS.type == "windows") {
[01:29:32.051]                 old_names <- names(...future.oldEnvVars)
[01:29:32.051]                 envs <- base::Sys.getenv()
[01:29:32.051]                 names <- names(envs)
[01:29:32.051]                 common <- intersect(names, old_names)
[01:29:32.051]                 added <- setdiff(names, old_names)
[01:29:32.051]                 removed <- setdiff(old_names, names)
[01:29:32.051]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:32.051]                   envs[common]]
[01:29:32.051]                 NAMES <- toupper(changed)
[01:29:32.051]                 args <- list()
[01:29:32.051]                 for (kk in seq_along(NAMES)) {
[01:29:32.051]                   name <- changed[[kk]]
[01:29:32.051]                   NAME <- NAMES[[kk]]
[01:29:32.051]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.051]                     next
[01:29:32.051]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.051]                 }
[01:29:32.051]                 NAMES <- toupper(added)
[01:29:32.051]                 for (kk in seq_along(NAMES)) {
[01:29:32.051]                   name <- added[[kk]]
[01:29:32.051]                   NAME <- NAMES[[kk]]
[01:29:32.051]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.051]                     next
[01:29:32.051]                   args[[name]] <- ""
[01:29:32.051]                 }
[01:29:32.051]                 NAMES <- toupper(removed)
[01:29:32.051]                 for (kk in seq_along(NAMES)) {
[01:29:32.051]                   name <- removed[[kk]]
[01:29:32.051]                   NAME <- NAMES[[kk]]
[01:29:32.051]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.051]                     next
[01:29:32.051]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.051]                 }
[01:29:32.051]                 if (length(args) > 0) 
[01:29:32.051]                   base::do.call(base::Sys.setenv, args = args)
[01:29:32.051]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:32.051]             }
[01:29:32.051]             else {
[01:29:32.051]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:32.051]             }
[01:29:32.051]             {
[01:29:32.051]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:32.051]                   0L) {
[01:29:32.051]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:32.051]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:32.051]                   base::options(opts)
[01:29:32.051]                 }
[01:29:32.051]                 {
[01:29:32.051]                   {
[01:29:32.051]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:32.051]                     NULL
[01:29:32.051]                   }
[01:29:32.051]                   options(future.plan = NULL)
[01:29:32.051]                   if (is.na(NA_character_)) 
[01:29:32.051]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.051]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:32.051]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:32.051]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:32.051]                     envir = parent.frame()) 
[01:29:32.051]                   {
[01:29:32.051]                     if (is.function(workers)) 
[01:29:32.051]                       workers <- workers()
[01:29:32.051]                     workers <- structure(as.integer(workers), 
[01:29:32.051]                       class = class(workers))
[01:29:32.051]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:32.051]                       workers >= 1)
[01:29:32.051]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:32.051]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:32.051]                     }
[01:29:32.051]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:32.051]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:32.051]                       envir = envir)
[01:29:32.051]                     if (!future$lazy) 
[01:29:32.051]                       future <- run(future)
[01:29:32.051]                     invisible(future)
[01:29:32.051]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:32.051]                 }
[01:29:32.051]             }
[01:29:32.051]         }
[01:29:32.051]     })
[01:29:32.051]     if (TRUE) {
[01:29:32.051]         base::sink(type = "output", split = FALSE)
[01:29:32.051]         if (TRUE) {
[01:29:32.051]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:32.051]         }
[01:29:32.051]         else {
[01:29:32.051]             ...future.result["stdout"] <- base::list(NULL)
[01:29:32.051]         }
[01:29:32.051]         base::close(...future.stdout)
[01:29:32.051]         ...future.stdout <- NULL
[01:29:32.051]     }
[01:29:32.051]     ...future.result$conditions <- ...future.conditions
[01:29:32.051]     ...future.result$finished <- base::Sys.time()
[01:29:32.051]     ...future.result
[01:29:32.051] }
[01:29:32.057] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:32.057] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:32.057] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:32.058] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:32.058] MultisessionFuture started
[01:29:32.059] - Launch lazy future ... done
[01:29:32.059] run() for 'MultisessionFuture' ... done
[01:29:32.059] getGlobalsAndPackages() ...
[01:29:32.060] Searching for globals...
[01:29:32.061] - globals found: [3] '{', 'sample', 'x'
[01:29:32.061] Searching for globals ... DONE
[01:29:32.061] Resolving globals: FALSE
[01:29:32.062] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:32.062] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:32.063] - globals: [1] 'x'
[01:29:32.063] 
[01:29:32.063] getGlobalsAndPackages() ... DONE
[01:29:32.063] run() for 'Future' ...
[01:29:32.063] - state: 'created'
[01:29:32.064] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:32.079] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:32.080] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:32.080]   - Field: 'node'
[01:29:32.080]   - Field: 'label'
[01:29:32.080]   - Field: 'local'
[01:29:32.081]   - Field: 'owner'
[01:29:32.081]   - Field: 'envir'
[01:29:32.081]   - Field: 'workers'
[01:29:32.082]   - Field: 'packages'
[01:29:32.082]   - Field: 'gc'
[01:29:32.082]   - Field: 'conditions'
[01:29:32.082]   - Field: 'persistent'
[01:29:32.082]   - Field: 'expr'
[01:29:32.083]   - Field: 'uuid'
[01:29:32.083]   - Field: 'seed'
[01:29:32.083]   - Field: 'version'
[01:29:32.083]   - Field: 'result'
[01:29:32.084]   - Field: 'asynchronous'
[01:29:32.084]   - Field: 'calls'
[01:29:32.084]   - Field: 'globals'
[01:29:32.084]   - Field: 'stdout'
[01:29:32.084]   - Field: 'earlySignal'
[01:29:32.085]   - Field: 'lazy'
[01:29:32.085]   - Field: 'state'
[01:29:32.085] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:32.085] - Launch lazy future ...
[01:29:32.086] Packages needed by the future expression (n = 0): <none>
[01:29:32.086] Packages needed by future strategies (n = 0): <none>
[01:29:32.087] {
[01:29:32.087]     {
[01:29:32.087]         {
[01:29:32.087]             ...future.startTime <- base::Sys.time()
[01:29:32.087]             {
[01:29:32.087]                 {
[01:29:32.087]                   {
[01:29:32.087]                     {
[01:29:32.087]                       base::local({
[01:29:32.087]                         has_future <- base::requireNamespace("future", 
[01:29:32.087]                           quietly = TRUE)
[01:29:32.087]                         if (has_future) {
[01:29:32.087]                           ns <- base::getNamespace("future")
[01:29:32.087]                           version <- ns[[".package"]][["version"]]
[01:29:32.087]                           if (is.null(version)) 
[01:29:32.087]                             version <- utils::packageVersion("future")
[01:29:32.087]                         }
[01:29:32.087]                         else {
[01:29:32.087]                           version <- NULL
[01:29:32.087]                         }
[01:29:32.087]                         if (!has_future || version < "1.8.0") {
[01:29:32.087]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:32.087]                             "", base::R.version$version.string), 
[01:29:32.087]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:32.087]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:32.087]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:32.087]                               "release", "version")], collapse = " "), 
[01:29:32.087]                             hostname = base::Sys.info()[["nodename"]])
[01:29:32.087]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:32.087]                             info)
[01:29:32.087]                           info <- base::paste(info, collapse = "; ")
[01:29:32.087]                           if (!has_future) {
[01:29:32.087]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:32.087]                               info)
[01:29:32.087]                           }
[01:29:32.087]                           else {
[01:29:32.087]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:32.087]                               info, version)
[01:29:32.087]                           }
[01:29:32.087]                           base::stop(msg)
[01:29:32.087]                         }
[01:29:32.087]                       })
[01:29:32.087]                     }
[01:29:32.087]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:32.087]                     base::options(mc.cores = 1L)
[01:29:32.087]                   }
[01:29:32.087]                   options(future.plan = NULL)
[01:29:32.087]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.087]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:32.087]                 }
[01:29:32.087]                 ...future.workdir <- getwd()
[01:29:32.087]             }
[01:29:32.087]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:32.087]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:32.087]         }
[01:29:32.087]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:32.087]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:32.087]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:32.087]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:32.087]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:32.087]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:32.087]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:32.087]             base::names(...future.oldOptions))
[01:29:32.087]     }
[01:29:32.087]     if (FALSE) {
[01:29:32.087]     }
[01:29:32.087]     else {
[01:29:32.087]         if (TRUE) {
[01:29:32.087]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:32.087]                 open = "w")
[01:29:32.087]         }
[01:29:32.087]         else {
[01:29:32.087]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:32.087]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:32.087]         }
[01:29:32.087]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:32.087]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:32.087]             base::sink(type = "output", split = FALSE)
[01:29:32.087]             base::close(...future.stdout)
[01:29:32.087]         }, add = TRUE)
[01:29:32.087]     }
[01:29:32.087]     ...future.frame <- base::sys.nframe()
[01:29:32.087]     ...future.conditions <- base::list()
[01:29:32.087]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:32.087]     if (FALSE) {
[01:29:32.087]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:32.087]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:32.087]     }
[01:29:32.087]     ...future.result <- base::tryCatch({
[01:29:32.087]         base::withCallingHandlers({
[01:29:32.087]             ...future.value <- base::withVisible(base::local({
[01:29:32.087]                 ...future.makeSendCondition <- base::local({
[01:29:32.087]                   sendCondition <- NULL
[01:29:32.087]                   function(frame = 1L) {
[01:29:32.087]                     if (is.function(sendCondition)) 
[01:29:32.087]                       return(sendCondition)
[01:29:32.087]                     ns <- getNamespace("parallel")
[01:29:32.087]                     if (exists("sendData", mode = "function", 
[01:29:32.087]                       envir = ns)) {
[01:29:32.087]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:32.087]                         envir = ns)
[01:29:32.087]                       envir <- sys.frame(frame)
[01:29:32.087]                       master <- NULL
[01:29:32.087]                       while (!identical(envir, .GlobalEnv) && 
[01:29:32.087]                         !identical(envir, emptyenv())) {
[01:29:32.087]                         if (exists("master", mode = "list", envir = envir, 
[01:29:32.087]                           inherits = FALSE)) {
[01:29:32.087]                           master <- get("master", mode = "list", 
[01:29:32.087]                             envir = envir, inherits = FALSE)
[01:29:32.087]                           if (inherits(master, c("SOCKnode", 
[01:29:32.087]                             "SOCK0node"))) {
[01:29:32.087]                             sendCondition <<- function(cond) {
[01:29:32.087]                               data <- list(type = "VALUE", value = cond, 
[01:29:32.087]                                 success = TRUE)
[01:29:32.087]                               parallel_sendData(master, data)
[01:29:32.087]                             }
[01:29:32.087]                             return(sendCondition)
[01:29:32.087]                           }
[01:29:32.087]                         }
[01:29:32.087]                         frame <- frame + 1L
[01:29:32.087]                         envir <- sys.frame(frame)
[01:29:32.087]                       }
[01:29:32.087]                     }
[01:29:32.087]                     sendCondition <<- function(cond) NULL
[01:29:32.087]                   }
[01:29:32.087]                 })
[01:29:32.087]                 withCallingHandlers({
[01:29:32.087]                   {
[01:29:32.087]                     sample(x, size = 1L)
[01:29:32.087]                   }
[01:29:32.087]                 }, immediateCondition = function(cond) {
[01:29:32.087]                   sendCondition <- ...future.makeSendCondition()
[01:29:32.087]                   sendCondition(cond)
[01:29:32.087]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.087]                   {
[01:29:32.087]                     inherits <- base::inherits
[01:29:32.087]                     invokeRestart <- base::invokeRestart
[01:29:32.087]                     is.null <- base::is.null
[01:29:32.087]                     muffled <- FALSE
[01:29:32.087]                     if (inherits(cond, "message")) {
[01:29:32.087]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:32.087]                       if (muffled) 
[01:29:32.087]                         invokeRestart("muffleMessage")
[01:29:32.087]                     }
[01:29:32.087]                     else if (inherits(cond, "warning")) {
[01:29:32.087]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:32.087]                       if (muffled) 
[01:29:32.087]                         invokeRestart("muffleWarning")
[01:29:32.087]                     }
[01:29:32.087]                     else if (inherits(cond, "condition")) {
[01:29:32.087]                       if (!is.null(pattern)) {
[01:29:32.087]                         computeRestarts <- base::computeRestarts
[01:29:32.087]                         grepl <- base::grepl
[01:29:32.087]                         restarts <- computeRestarts(cond)
[01:29:32.087]                         for (restart in restarts) {
[01:29:32.087]                           name <- restart$name
[01:29:32.087]                           if (is.null(name)) 
[01:29:32.087]                             next
[01:29:32.087]                           if (!grepl(pattern, name)) 
[01:29:32.087]                             next
[01:29:32.087]                           invokeRestart(restart)
[01:29:32.087]                           muffled <- TRUE
[01:29:32.087]                           break
[01:29:32.087]                         }
[01:29:32.087]                       }
[01:29:32.087]                     }
[01:29:32.087]                     invisible(muffled)
[01:29:32.087]                   }
[01:29:32.087]                   muffleCondition(cond)
[01:29:32.087]                 })
[01:29:32.087]             }))
[01:29:32.087]             future::FutureResult(value = ...future.value$value, 
[01:29:32.087]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.087]                   ...future.rng), globalenv = if (FALSE) 
[01:29:32.087]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:32.087]                     ...future.globalenv.names))
[01:29:32.087]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:32.087]         }, condition = base::local({
[01:29:32.087]             c <- base::c
[01:29:32.087]             inherits <- base::inherits
[01:29:32.087]             invokeRestart <- base::invokeRestart
[01:29:32.087]             length <- base::length
[01:29:32.087]             list <- base::list
[01:29:32.087]             seq.int <- base::seq.int
[01:29:32.087]             signalCondition <- base::signalCondition
[01:29:32.087]             sys.calls <- base::sys.calls
[01:29:32.087]             `[[` <- base::`[[`
[01:29:32.087]             `+` <- base::`+`
[01:29:32.087]             `<<-` <- base::`<<-`
[01:29:32.087]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:32.087]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:32.087]                   3L)]
[01:29:32.087]             }
[01:29:32.087]             function(cond) {
[01:29:32.087]                 is_error <- inherits(cond, "error")
[01:29:32.087]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:32.087]                   NULL)
[01:29:32.087]                 if (is_error) {
[01:29:32.087]                   sessionInformation <- function() {
[01:29:32.087]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:32.087]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:32.087]                       search = base::search(), system = base::Sys.info())
[01:29:32.087]                   }
[01:29:32.087]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.087]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:32.087]                     cond$call), session = sessionInformation(), 
[01:29:32.087]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:32.087]                   signalCondition(cond)
[01:29:32.087]                 }
[01:29:32.087]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:32.087]                 "immediateCondition"))) {
[01:29:32.087]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:32.087]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.087]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:32.087]                   if (TRUE && !signal) {
[01:29:32.087]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.087]                     {
[01:29:32.087]                       inherits <- base::inherits
[01:29:32.087]                       invokeRestart <- base::invokeRestart
[01:29:32.087]                       is.null <- base::is.null
[01:29:32.087]                       muffled <- FALSE
[01:29:32.087]                       if (inherits(cond, "message")) {
[01:29:32.087]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.087]                         if (muffled) 
[01:29:32.087]                           invokeRestart("muffleMessage")
[01:29:32.087]                       }
[01:29:32.087]                       else if (inherits(cond, "warning")) {
[01:29:32.087]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.087]                         if (muffled) 
[01:29:32.087]                           invokeRestart("muffleWarning")
[01:29:32.087]                       }
[01:29:32.087]                       else if (inherits(cond, "condition")) {
[01:29:32.087]                         if (!is.null(pattern)) {
[01:29:32.087]                           computeRestarts <- base::computeRestarts
[01:29:32.087]                           grepl <- base::grepl
[01:29:32.087]                           restarts <- computeRestarts(cond)
[01:29:32.087]                           for (restart in restarts) {
[01:29:32.087]                             name <- restart$name
[01:29:32.087]                             if (is.null(name)) 
[01:29:32.087]                               next
[01:29:32.087]                             if (!grepl(pattern, name)) 
[01:29:32.087]                               next
[01:29:32.087]                             invokeRestart(restart)
[01:29:32.087]                             muffled <- TRUE
[01:29:32.087]                             break
[01:29:32.087]                           }
[01:29:32.087]                         }
[01:29:32.087]                       }
[01:29:32.087]                       invisible(muffled)
[01:29:32.087]                     }
[01:29:32.087]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.087]                   }
[01:29:32.087]                 }
[01:29:32.087]                 else {
[01:29:32.087]                   if (TRUE) {
[01:29:32.087]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.087]                     {
[01:29:32.087]                       inherits <- base::inherits
[01:29:32.087]                       invokeRestart <- base::invokeRestart
[01:29:32.087]                       is.null <- base::is.null
[01:29:32.087]                       muffled <- FALSE
[01:29:32.087]                       if (inherits(cond, "message")) {
[01:29:32.087]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.087]                         if (muffled) 
[01:29:32.087]                           invokeRestart("muffleMessage")
[01:29:32.087]                       }
[01:29:32.087]                       else if (inherits(cond, "warning")) {
[01:29:32.087]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.087]                         if (muffled) 
[01:29:32.087]                           invokeRestart("muffleWarning")
[01:29:32.087]                       }
[01:29:32.087]                       else if (inherits(cond, "condition")) {
[01:29:32.087]                         if (!is.null(pattern)) {
[01:29:32.087]                           computeRestarts <- base::computeRestarts
[01:29:32.087]                           grepl <- base::grepl
[01:29:32.087]                           restarts <- computeRestarts(cond)
[01:29:32.087]                           for (restart in restarts) {
[01:29:32.087]                             name <- restart$name
[01:29:32.087]                             if (is.null(name)) 
[01:29:32.087]                               next
[01:29:32.087]                             if (!grepl(pattern, name)) 
[01:29:32.087]                               next
[01:29:32.087]                             invokeRestart(restart)
[01:29:32.087]                             muffled <- TRUE
[01:29:32.087]                             break
[01:29:32.087]                           }
[01:29:32.087]                         }
[01:29:32.087]                       }
[01:29:32.087]                       invisible(muffled)
[01:29:32.087]                     }
[01:29:32.087]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.087]                   }
[01:29:32.087]                 }
[01:29:32.087]             }
[01:29:32.087]         }))
[01:29:32.087]     }, error = function(ex) {
[01:29:32.087]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:32.087]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.087]                 ...future.rng), started = ...future.startTime, 
[01:29:32.087]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:32.087]             version = "1.8"), class = "FutureResult")
[01:29:32.087]     }, finally = {
[01:29:32.087]         if (!identical(...future.workdir, getwd())) 
[01:29:32.087]             setwd(...future.workdir)
[01:29:32.087]         {
[01:29:32.087]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:32.087]                 ...future.oldOptions$nwarnings <- NULL
[01:29:32.087]             }
[01:29:32.087]             base::options(...future.oldOptions)
[01:29:32.087]             if (.Platform$OS.type == "windows") {
[01:29:32.087]                 old_names <- names(...future.oldEnvVars)
[01:29:32.087]                 envs <- base::Sys.getenv()
[01:29:32.087]                 names <- names(envs)
[01:29:32.087]                 common <- intersect(names, old_names)
[01:29:32.087]                 added <- setdiff(names, old_names)
[01:29:32.087]                 removed <- setdiff(old_names, names)
[01:29:32.087]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:32.087]                   envs[common]]
[01:29:32.087]                 NAMES <- toupper(changed)
[01:29:32.087]                 args <- list()
[01:29:32.087]                 for (kk in seq_along(NAMES)) {
[01:29:32.087]                   name <- changed[[kk]]
[01:29:32.087]                   NAME <- NAMES[[kk]]
[01:29:32.087]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.087]                     next
[01:29:32.087]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.087]                 }
[01:29:32.087]                 NAMES <- toupper(added)
[01:29:32.087]                 for (kk in seq_along(NAMES)) {
[01:29:32.087]                   name <- added[[kk]]
[01:29:32.087]                   NAME <- NAMES[[kk]]
[01:29:32.087]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.087]                     next
[01:29:32.087]                   args[[name]] <- ""
[01:29:32.087]                 }
[01:29:32.087]                 NAMES <- toupper(removed)
[01:29:32.087]                 for (kk in seq_along(NAMES)) {
[01:29:32.087]                   name <- removed[[kk]]
[01:29:32.087]                   NAME <- NAMES[[kk]]
[01:29:32.087]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.087]                     next
[01:29:32.087]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.087]                 }
[01:29:32.087]                 if (length(args) > 0) 
[01:29:32.087]                   base::do.call(base::Sys.setenv, args = args)
[01:29:32.087]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:32.087]             }
[01:29:32.087]             else {
[01:29:32.087]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:32.087]             }
[01:29:32.087]             {
[01:29:32.087]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:32.087]                   0L) {
[01:29:32.087]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:32.087]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:32.087]                   base::options(opts)
[01:29:32.087]                 }
[01:29:32.087]                 {
[01:29:32.087]                   {
[01:29:32.087]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:32.087]                     NULL
[01:29:32.087]                   }
[01:29:32.087]                   options(future.plan = NULL)
[01:29:32.087]                   if (is.na(NA_character_)) 
[01:29:32.087]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.087]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:32.087]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:32.087]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:32.087]                     envir = parent.frame()) 
[01:29:32.087]                   {
[01:29:32.087]                     if (is.function(workers)) 
[01:29:32.087]                       workers <- workers()
[01:29:32.087]                     workers <- structure(as.integer(workers), 
[01:29:32.087]                       class = class(workers))
[01:29:32.087]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:32.087]                       workers >= 1)
[01:29:32.087]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:32.087]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:32.087]                     }
[01:29:32.087]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:32.087]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:32.087]                       envir = envir)
[01:29:32.087]                     if (!future$lazy) 
[01:29:32.087]                       future <- run(future)
[01:29:32.087]                     invisible(future)
[01:29:32.087]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:32.087]                 }
[01:29:32.087]             }
[01:29:32.087]         }
[01:29:32.087]     })
[01:29:32.087]     if (TRUE) {
[01:29:32.087]         base::sink(type = "output", split = FALSE)
[01:29:32.087]         if (TRUE) {
[01:29:32.087]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:32.087]         }
[01:29:32.087]         else {
[01:29:32.087]             ...future.result["stdout"] <- base::list(NULL)
[01:29:32.087]         }
[01:29:32.087]         base::close(...future.stdout)
[01:29:32.087]         ...future.stdout <- NULL
[01:29:32.087]     }
[01:29:32.087]     ...future.result$conditions <- ...future.conditions
[01:29:32.087]     ...future.result$finished <- base::Sys.time()
[01:29:32.087]     ...future.result
[01:29:32.087] }
[01:29:32.094] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:32.095] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:32.095] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:32.096] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:32.096] MultisessionFuture started
[01:29:32.097] - Launch lazy future ... done
[01:29:32.097] run() for 'MultisessionFuture' ... done
[01:29:32.097] getGlobalsAndPackages() ...
[01:29:32.098] Searching for globals...
[01:29:32.099] - globals found: [3] '{', 'sample', 'x'
[01:29:32.099] Searching for globals ... DONE
[01:29:32.100] Resolving globals: FALSE
[01:29:32.100] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:32.101] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:32.101] - globals: [1] 'x'
[01:29:32.101] 
[01:29:32.101] getGlobalsAndPackages() ... DONE
[01:29:32.102] run() for 'Future' ...
[01:29:32.102] - state: 'created'
[01:29:32.102] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:32.117] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:32.117] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:32.117]   - Field: 'node'
[01:29:32.118]   - Field: 'label'
[01:29:32.118]   - Field: 'local'
[01:29:32.118]   - Field: 'owner'
[01:29:32.118]   - Field: 'envir'
[01:29:32.118]   - Field: 'workers'
[01:29:32.119]   - Field: 'packages'
[01:29:32.119]   - Field: 'gc'
[01:29:32.119]   - Field: 'conditions'
[01:29:32.119]   - Field: 'persistent'
[01:29:32.119]   - Field: 'expr'
[01:29:32.120]   - Field: 'uuid'
[01:29:32.120]   - Field: 'seed'
[01:29:32.120]   - Field: 'version'
[01:29:32.120]   - Field: 'result'
[01:29:32.120]   - Field: 'asynchronous'
[01:29:32.121]   - Field: 'calls'
[01:29:32.121]   - Field: 'globals'
[01:29:32.121]   - Field: 'stdout'
[01:29:32.121]   - Field: 'earlySignal'
[01:29:32.121]   - Field: 'lazy'
[01:29:32.122]   - Field: 'state'
[01:29:32.122] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:32.122] - Launch lazy future ...
[01:29:32.122] Packages needed by the future expression (n = 0): <none>
[01:29:32.123] Packages needed by future strategies (n = 0): <none>
[01:29:32.123] {
[01:29:32.123]     {
[01:29:32.123]         {
[01:29:32.123]             ...future.startTime <- base::Sys.time()
[01:29:32.123]             {
[01:29:32.123]                 {
[01:29:32.123]                   {
[01:29:32.123]                     {
[01:29:32.123]                       base::local({
[01:29:32.123]                         has_future <- base::requireNamespace("future", 
[01:29:32.123]                           quietly = TRUE)
[01:29:32.123]                         if (has_future) {
[01:29:32.123]                           ns <- base::getNamespace("future")
[01:29:32.123]                           version <- ns[[".package"]][["version"]]
[01:29:32.123]                           if (is.null(version)) 
[01:29:32.123]                             version <- utils::packageVersion("future")
[01:29:32.123]                         }
[01:29:32.123]                         else {
[01:29:32.123]                           version <- NULL
[01:29:32.123]                         }
[01:29:32.123]                         if (!has_future || version < "1.8.0") {
[01:29:32.123]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:32.123]                             "", base::R.version$version.string), 
[01:29:32.123]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:32.123]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:32.123]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:32.123]                               "release", "version")], collapse = " "), 
[01:29:32.123]                             hostname = base::Sys.info()[["nodename"]])
[01:29:32.123]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:32.123]                             info)
[01:29:32.123]                           info <- base::paste(info, collapse = "; ")
[01:29:32.123]                           if (!has_future) {
[01:29:32.123]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:32.123]                               info)
[01:29:32.123]                           }
[01:29:32.123]                           else {
[01:29:32.123]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:32.123]                               info, version)
[01:29:32.123]                           }
[01:29:32.123]                           base::stop(msg)
[01:29:32.123]                         }
[01:29:32.123]                       })
[01:29:32.123]                     }
[01:29:32.123]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:32.123]                     base::options(mc.cores = 1L)
[01:29:32.123]                   }
[01:29:32.123]                   options(future.plan = NULL)
[01:29:32.123]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.123]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:32.123]                 }
[01:29:32.123]                 ...future.workdir <- getwd()
[01:29:32.123]             }
[01:29:32.123]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:32.123]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:32.123]         }
[01:29:32.123]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:32.123]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:32.123]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:32.123]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:32.123]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:32.123]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:32.123]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:32.123]             base::names(...future.oldOptions))
[01:29:32.123]     }
[01:29:32.123]     if (FALSE) {
[01:29:32.123]     }
[01:29:32.123]     else {
[01:29:32.123]         if (TRUE) {
[01:29:32.123]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:32.123]                 open = "w")
[01:29:32.123]         }
[01:29:32.123]         else {
[01:29:32.123]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:32.123]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:32.123]         }
[01:29:32.123]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:32.123]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:32.123]             base::sink(type = "output", split = FALSE)
[01:29:32.123]             base::close(...future.stdout)
[01:29:32.123]         }, add = TRUE)
[01:29:32.123]     }
[01:29:32.123]     ...future.frame <- base::sys.nframe()
[01:29:32.123]     ...future.conditions <- base::list()
[01:29:32.123]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:32.123]     if (FALSE) {
[01:29:32.123]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:32.123]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:32.123]     }
[01:29:32.123]     ...future.result <- base::tryCatch({
[01:29:32.123]         base::withCallingHandlers({
[01:29:32.123]             ...future.value <- base::withVisible(base::local({
[01:29:32.123]                 ...future.makeSendCondition <- base::local({
[01:29:32.123]                   sendCondition <- NULL
[01:29:32.123]                   function(frame = 1L) {
[01:29:32.123]                     if (is.function(sendCondition)) 
[01:29:32.123]                       return(sendCondition)
[01:29:32.123]                     ns <- getNamespace("parallel")
[01:29:32.123]                     if (exists("sendData", mode = "function", 
[01:29:32.123]                       envir = ns)) {
[01:29:32.123]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:32.123]                         envir = ns)
[01:29:32.123]                       envir <- sys.frame(frame)
[01:29:32.123]                       master <- NULL
[01:29:32.123]                       while (!identical(envir, .GlobalEnv) && 
[01:29:32.123]                         !identical(envir, emptyenv())) {
[01:29:32.123]                         if (exists("master", mode = "list", envir = envir, 
[01:29:32.123]                           inherits = FALSE)) {
[01:29:32.123]                           master <- get("master", mode = "list", 
[01:29:32.123]                             envir = envir, inherits = FALSE)
[01:29:32.123]                           if (inherits(master, c("SOCKnode", 
[01:29:32.123]                             "SOCK0node"))) {
[01:29:32.123]                             sendCondition <<- function(cond) {
[01:29:32.123]                               data <- list(type = "VALUE", value = cond, 
[01:29:32.123]                                 success = TRUE)
[01:29:32.123]                               parallel_sendData(master, data)
[01:29:32.123]                             }
[01:29:32.123]                             return(sendCondition)
[01:29:32.123]                           }
[01:29:32.123]                         }
[01:29:32.123]                         frame <- frame + 1L
[01:29:32.123]                         envir <- sys.frame(frame)
[01:29:32.123]                       }
[01:29:32.123]                     }
[01:29:32.123]                     sendCondition <<- function(cond) NULL
[01:29:32.123]                   }
[01:29:32.123]                 })
[01:29:32.123]                 withCallingHandlers({
[01:29:32.123]                   {
[01:29:32.123]                     sample(x, size = 1L)
[01:29:32.123]                   }
[01:29:32.123]                 }, immediateCondition = function(cond) {
[01:29:32.123]                   sendCondition <- ...future.makeSendCondition()
[01:29:32.123]                   sendCondition(cond)
[01:29:32.123]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.123]                   {
[01:29:32.123]                     inherits <- base::inherits
[01:29:32.123]                     invokeRestart <- base::invokeRestart
[01:29:32.123]                     is.null <- base::is.null
[01:29:32.123]                     muffled <- FALSE
[01:29:32.123]                     if (inherits(cond, "message")) {
[01:29:32.123]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:32.123]                       if (muffled) 
[01:29:32.123]                         invokeRestart("muffleMessage")
[01:29:32.123]                     }
[01:29:32.123]                     else if (inherits(cond, "warning")) {
[01:29:32.123]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:32.123]                       if (muffled) 
[01:29:32.123]                         invokeRestart("muffleWarning")
[01:29:32.123]                     }
[01:29:32.123]                     else if (inherits(cond, "condition")) {
[01:29:32.123]                       if (!is.null(pattern)) {
[01:29:32.123]                         computeRestarts <- base::computeRestarts
[01:29:32.123]                         grepl <- base::grepl
[01:29:32.123]                         restarts <- computeRestarts(cond)
[01:29:32.123]                         for (restart in restarts) {
[01:29:32.123]                           name <- restart$name
[01:29:32.123]                           if (is.null(name)) 
[01:29:32.123]                             next
[01:29:32.123]                           if (!grepl(pattern, name)) 
[01:29:32.123]                             next
[01:29:32.123]                           invokeRestart(restart)
[01:29:32.123]                           muffled <- TRUE
[01:29:32.123]                           break
[01:29:32.123]                         }
[01:29:32.123]                       }
[01:29:32.123]                     }
[01:29:32.123]                     invisible(muffled)
[01:29:32.123]                   }
[01:29:32.123]                   muffleCondition(cond)
[01:29:32.123]                 })
[01:29:32.123]             }))
[01:29:32.123]             future::FutureResult(value = ...future.value$value, 
[01:29:32.123]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.123]                   ...future.rng), globalenv = if (FALSE) 
[01:29:32.123]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:32.123]                     ...future.globalenv.names))
[01:29:32.123]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:32.123]         }, condition = base::local({
[01:29:32.123]             c <- base::c
[01:29:32.123]             inherits <- base::inherits
[01:29:32.123]             invokeRestart <- base::invokeRestart
[01:29:32.123]             length <- base::length
[01:29:32.123]             list <- base::list
[01:29:32.123]             seq.int <- base::seq.int
[01:29:32.123]             signalCondition <- base::signalCondition
[01:29:32.123]             sys.calls <- base::sys.calls
[01:29:32.123]             `[[` <- base::`[[`
[01:29:32.123]             `+` <- base::`+`
[01:29:32.123]             `<<-` <- base::`<<-`
[01:29:32.123]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:32.123]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:32.123]                   3L)]
[01:29:32.123]             }
[01:29:32.123]             function(cond) {
[01:29:32.123]                 is_error <- inherits(cond, "error")
[01:29:32.123]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:32.123]                   NULL)
[01:29:32.123]                 if (is_error) {
[01:29:32.123]                   sessionInformation <- function() {
[01:29:32.123]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:32.123]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:32.123]                       search = base::search(), system = base::Sys.info())
[01:29:32.123]                   }
[01:29:32.123]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.123]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:32.123]                     cond$call), session = sessionInformation(), 
[01:29:32.123]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:32.123]                   signalCondition(cond)
[01:29:32.123]                 }
[01:29:32.123]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:32.123]                 "immediateCondition"))) {
[01:29:32.123]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:32.123]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.123]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:32.123]                   if (TRUE && !signal) {
[01:29:32.123]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.123]                     {
[01:29:32.123]                       inherits <- base::inherits
[01:29:32.123]                       invokeRestart <- base::invokeRestart
[01:29:32.123]                       is.null <- base::is.null
[01:29:32.123]                       muffled <- FALSE
[01:29:32.123]                       if (inherits(cond, "message")) {
[01:29:32.123]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.123]                         if (muffled) 
[01:29:32.123]                           invokeRestart("muffleMessage")
[01:29:32.123]                       }
[01:29:32.123]                       else if (inherits(cond, "warning")) {
[01:29:32.123]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.123]                         if (muffled) 
[01:29:32.123]                           invokeRestart("muffleWarning")
[01:29:32.123]                       }
[01:29:32.123]                       else if (inherits(cond, "condition")) {
[01:29:32.123]                         if (!is.null(pattern)) {
[01:29:32.123]                           computeRestarts <- base::computeRestarts
[01:29:32.123]                           grepl <- base::grepl
[01:29:32.123]                           restarts <- computeRestarts(cond)
[01:29:32.123]                           for (restart in restarts) {
[01:29:32.123]                             name <- restart$name
[01:29:32.123]                             if (is.null(name)) 
[01:29:32.123]                               next
[01:29:32.123]                             if (!grepl(pattern, name)) 
[01:29:32.123]                               next
[01:29:32.123]                             invokeRestart(restart)
[01:29:32.123]                             muffled <- TRUE
[01:29:32.123]                             break
[01:29:32.123]                           }
[01:29:32.123]                         }
[01:29:32.123]                       }
[01:29:32.123]                       invisible(muffled)
[01:29:32.123]                     }
[01:29:32.123]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.123]                   }
[01:29:32.123]                 }
[01:29:32.123]                 else {
[01:29:32.123]                   if (TRUE) {
[01:29:32.123]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.123]                     {
[01:29:32.123]                       inherits <- base::inherits
[01:29:32.123]                       invokeRestart <- base::invokeRestart
[01:29:32.123]                       is.null <- base::is.null
[01:29:32.123]                       muffled <- FALSE
[01:29:32.123]                       if (inherits(cond, "message")) {
[01:29:32.123]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.123]                         if (muffled) 
[01:29:32.123]                           invokeRestart("muffleMessage")
[01:29:32.123]                       }
[01:29:32.123]                       else if (inherits(cond, "warning")) {
[01:29:32.123]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.123]                         if (muffled) 
[01:29:32.123]                           invokeRestart("muffleWarning")
[01:29:32.123]                       }
[01:29:32.123]                       else if (inherits(cond, "condition")) {
[01:29:32.123]                         if (!is.null(pattern)) {
[01:29:32.123]                           computeRestarts <- base::computeRestarts
[01:29:32.123]                           grepl <- base::grepl
[01:29:32.123]                           restarts <- computeRestarts(cond)
[01:29:32.123]                           for (restart in restarts) {
[01:29:32.123]                             name <- restart$name
[01:29:32.123]                             if (is.null(name)) 
[01:29:32.123]                               next
[01:29:32.123]                             if (!grepl(pattern, name)) 
[01:29:32.123]                               next
[01:29:32.123]                             invokeRestart(restart)
[01:29:32.123]                             muffled <- TRUE
[01:29:32.123]                             break
[01:29:32.123]                           }
[01:29:32.123]                         }
[01:29:32.123]                       }
[01:29:32.123]                       invisible(muffled)
[01:29:32.123]                     }
[01:29:32.123]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.123]                   }
[01:29:32.123]                 }
[01:29:32.123]             }
[01:29:32.123]         }))
[01:29:32.123]     }, error = function(ex) {
[01:29:32.123]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:32.123]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.123]                 ...future.rng), started = ...future.startTime, 
[01:29:32.123]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:32.123]             version = "1.8"), class = "FutureResult")
[01:29:32.123]     }, finally = {
[01:29:32.123]         if (!identical(...future.workdir, getwd())) 
[01:29:32.123]             setwd(...future.workdir)
[01:29:32.123]         {
[01:29:32.123]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:32.123]                 ...future.oldOptions$nwarnings <- NULL
[01:29:32.123]             }
[01:29:32.123]             base::options(...future.oldOptions)
[01:29:32.123]             if (.Platform$OS.type == "windows") {
[01:29:32.123]                 old_names <- names(...future.oldEnvVars)
[01:29:32.123]                 envs <- base::Sys.getenv()
[01:29:32.123]                 names <- names(envs)
[01:29:32.123]                 common <- intersect(names, old_names)
[01:29:32.123]                 added <- setdiff(names, old_names)
[01:29:32.123]                 removed <- setdiff(old_names, names)
[01:29:32.123]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:32.123]                   envs[common]]
[01:29:32.123]                 NAMES <- toupper(changed)
[01:29:32.123]                 args <- list()
[01:29:32.123]                 for (kk in seq_along(NAMES)) {
[01:29:32.123]                   name <- changed[[kk]]
[01:29:32.123]                   NAME <- NAMES[[kk]]
[01:29:32.123]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.123]                     next
[01:29:32.123]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.123]                 }
[01:29:32.123]                 NAMES <- toupper(added)
[01:29:32.123]                 for (kk in seq_along(NAMES)) {
[01:29:32.123]                   name <- added[[kk]]
[01:29:32.123]                   NAME <- NAMES[[kk]]
[01:29:32.123]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.123]                     next
[01:29:32.123]                   args[[name]] <- ""
[01:29:32.123]                 }
[01:29:32.123]                 NAMES <- toupper(removed)
[01:29:32.123]                 for (kk in seq_along(NAMES)) {
[01:29:32.123]                   name <- removed[[kk]]
[01:29:32.123]                   NAME <- NAMES[[kk]]
[01:29:32.123]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.123]                     next
[01:29:32.123]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.123]                 }
[01:29:32.123]                 if (length(args) > 0) 
[01:29:32.123]                   base::do.call(base::Sys.setenv, args = args)
[01:29:32.123]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:32.123]             }
[01:29:32.123]             else {
[01:29:32.123]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:32.123]             }
[01:29:32.123]             {
[01:29:32.123]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:32.123]                   0L) {
[01:29:32.123]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:32.123]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:32.123]                   base::options(opts)
[01:29:32.123]                 }
[01:29:32.123]                 {
[01:29:32.123]                   {
[01:29:32.123]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:32.123]                     NULL
[01:29:32.123]                   }
[01:29:32.123]                   options(future.plan = NULL)
[01:29:32.123]                   if (is.na(NA_character_)) 
[01:29:32.123]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.123]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:32.123]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:32.123]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:32.123]                     envir = parent.frame()) 
[01:29:32.123]                   {
[01:29:32.123]                     if (is.function(workers)) 
[01:29:32.123]                       workers <- workers()
[01:29:32.123]                     workers <- structure(as.integer(workers), 
[01:29:32.123]                       class = class(workers))
[01:29:32.123]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:32.123]                       workers >= 1)
[01:29:32.123]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:32.123]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:32.123]                     }
[01:29:32.123]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:32.123]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:32.123]                       envir = envir)
[01:29:32.123]                     if (!future$lazy) 
[01:29:32.123]                       future <- run(future)
[01:29:32.123]                     invisible(future)
[01:29:32.123]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:32.123]                 }
[01:29:32.123]             }
[01:29:32.123]         }
[01:29:32.123]     })
[01:29:32.123]     if (TRUE) {
[01:29:32.123]         base::sink(type = "output", split = FALSE)
[01:29:32.123]         if (TRUE) {
[01:29:32.123]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:32.123]         }
[01:29:32.123]         else {
[01:29:32.123]             ...future.result["stdout"] <- base::list(NULL)
[01:29:32.123]         }
[01:29:32.123]         base::close(...future.stdout)
[01:29:32.123]         ...future.stdout <- NULL
[01:29:32.123]     }
[01:29:32.123]     ...future.result$conditions <- ...future.conditions
[01:29:32.123]     ...future.result$finished <- base::Sys.time()
[01:29:32.123]     ...future.result
[01:29:32.123] }
[01:29:32.129] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:32.143] receiveMessageFromWorker() for ClusterFuture ...
[01:29:32.144] - Validating connection of MultisessionFuture
[01:29:32.144] - received message: FutureResult
[01:29:32.144] - Received FutureResult
[01:29:32.144] - Erased future from FutureRegistry
[01:29:32.144] result() for ClusterFuture ...
[01:29:32.145] - result already collected: FutureResult
[01:29:32.145] result() for ClusterFuture ... done
[01:29:32.145] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:32.145] result() for ClusterFuture ...
[01:29:32.145] - result already collected: FutureResult
[01:29:32.146] result() for ClusterFuture ... done
[01:29:32.146] result() for ClusterFuture ...
[01:29:32.146] - result already collected: FutureResult
[01:29:32.146] result() for ClusterFuture ... done
[01:29:32.147] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:32.147] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:32.148] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:32.148] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:32.149] MultisessionFuture started
[01:29:32.149] - Launch lazy future ... done
[01:29:32.149] run() for 'MultisessionFuture' ... done
[01:29:32.150] getGlobalsAndPackages() ...
[01:29:32.150] Searching for globals...
[01:29:32.152] - globals found: [3] '{', 'sample', 'x'
[01:29:32.152] Searching for globals ... DONE
[01:29:32.152] Resolving globals: FALSE
[01:29:32.153] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:32.153] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:32.153] - globals: [1] 'x'
[01:29:32.154] 
[01:29:32.154] getGlobalsAndPackages() ... DONE
[01:29:32.154] run() for 'Future' ...
[01:29:32.154] - state: 'created'
[01:29:32.155] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:32.169] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:32.169] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:32.170]   - Field: 'node'
[01:29:32.170]   - Field: 'label'
[01:29:32.170]   - Field: 'local'
[01:29:32.170]   - Field: 'owner'
[01:29:32.170]   - Field: 'envir'
[01:29:32.171]   - Field: 'workers'
[01:29:32.171]   - Field: 'packages'
[01:29:32.171]   - Field: 'gc'
[01:29:32.171]   - Field: 'conditions'
[01:29:32.172]   - Field: 'persistent'
[01:29:32.172]   - Field: 'expr'
[01:29:32.172]   - Field: 'uuid'
[01:29:32.172]   - Field: 'seed'
[01:29:32.172]   - Field: 'version'
[01:29:32.173]   - Field: 'result'
[01:29:32.173]   - Field: 'asynchronous'
[01:29:32.173]   - Field: 'calls'
[01:29:32.173]   - Field: 'globals'
[01:29:32.173]   - Field: 'stdout'
[01:29:32.174]   - Field: 'earlySignal'
[01:29:32.174]   - Field: 'lazy'
[01:29:32.174]   - Field: 'state'
[01:29:32.175] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:32.176] - Launch lazy future ...
[01:29:32.177] Packages needed by the future expression (n = 0): <none>
[01:29:32.177] Packages needed by future strategies (n = 0): <none>
[01:29:32.178] {
[01:29:32.178]     {
[01:29:32.178]         {
[01:29:32.178]             ...future.startTime <- base::Sys.time()
[01:29:32.178]             {
[01:29:32.178]                 {
[01:29:32.178]                   {
[01:29:32.178]                     {
[01:29:32.178]                       base::local({
[01:29:32.178]                         has_future <- base::requireNamespace("future", 
[01:29:32.178]                           quietly = TRUE)
[01:29:32.178]                         if (has_future) {
[01:29:32.178]                           ns <- base::getNamespace("future")
[01:29:32.178]                           version <- ns[[".package"]][["version"]]
[01:29:32.178]                           if (is.null(version)) 
[01:29:32.178]                             version <- utils::packageVersion("future")
[01:29:32.178]                         }
[01:29:32.178]                         else {
[01:29:32.178]                           version <- NULL
[01:29:32.178]                         }
[01:29:32.178]                         if (!has_future || version < "1.8.0") {
[01:29:32.178]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:32.178]                             "", base::R.version$version.string), 
[01:29:32.178]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:32.178]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:32.178]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:32.178]                               "release", "version")], collapse = " "), 
[01:29:32.178]                             hostname = base::Sys.info()[["nodename"]])
[01:29:32.178]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:32.178]                             info)
[01:29:32.178]                           info <- base::paste(info, collapse = "; ")
[01:29:32.178]                           if (!has_future) {
[01:29:32.178]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:32.178]                               info)
[01:29:32.178]                           }
[01:29:32.178]                           else {
[01:29:32.178]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:32.178]                               info, version)
[01:29:32.178]                           }
[01:29:32.178]                           base::stop(msg)
[01:29:32.178]                         }
[01:29:32.178]                       })
[01:29:32.178]                     }
[01:29:32.178]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:32.178]                     base::options(mc.cores = 1L)
[01:29:32.178]                   }
[01:29:32.178]                   options(future.plan = NULL)
[01:29:32.178]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.178]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:32.178]                 }
[01:29:32.178]                 ...future.workdir <- getwd()
[01:29:32.178]             }
[01:29:32.178]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:32.178]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:32.178]         }
[01:29:32.178]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:32.178]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:32.178]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:32.178]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:32.178]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:32.178]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:32.178]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:32.178]             base::names(...future.oldOptions))
[01:29:32.178]     }
[01:29:32.178]     if (FALSE) {
[01:29:32.178]     }
[01:29:32.178]     else {
[01:29:32.178]         if (TRUE) {
[01:29:32.178]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:32.178]                 open = "w")
[01:29:32.178]         }
[01:29:32.178]         else {
[01:29:32.178]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:32.178]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:32.178]         }
[01:29:32.178]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:32.178]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:32.178]             base::sink(type = "output", split = FALSE)
[01:29:32.178]             base::close(...future.stdout)
[01:29:32.178]         }, add = TRUE)
[01:29:32.178]     }
[01:29:32.178]     ...future.frame <- base::sys.nframe()
[01:29:32.178]     ...future.conditions <- base::list()
[01:29:32.178]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:32.178]     if (FALSE) {
[01:29:32.178]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:32.178]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:32.178]     }
[01:29:32.178]     ...future.result <- base::tryCatch({
[01:29:32.178]         base::withCallingHandlers({
[01:29:32.178]             ...future.value <- base::withVisible(base::local({
[01:29:32.178]                 ...future.makeSendCondition <- base::local({
[01:29:32.178]                   sendCondition <- NULL
[01:29:32.178]                   function(frame = 1L) {
[01:29:32.178]                     if (is.function(sendCondition)) 
[01:29:32.178]                       return(sendCondition)
[01:29:32.178]                     ns <- getNamespace("parallel")
[01:29:32.178]                     if (exists("sendData", mode = "function", 
[01:29:32.178]                       envir = ns)) {
[01:29:32.178]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:32.178]                         envir = ns)
[01:29:32.178]                       envir <- sys.frame(frame)
[01:29:32.178]                       master <- NULL
[01:29:32.178]                       while (!identical(envir, .GlobalEnv) && 
[01:29:32.178]                         !identical(envir, emptyenv())) {
[01:29:32.178]                         if (exists("master", mode = "list", envir = envir, 
[01:29:32.178]                           inherits = FALSE)) {
[01:29:32.178]                           master <- get("master", mode = "list", 
[01:29:32.178]                             envir = envir, inherits = FALSE)
[01:29:32.178]                           if (inherits(master, c("SOCKnode", 
[01:29:32.178]                             "SOCK0node"))) {
[01:29:32.178]                             sendCondition <<- function(cond) {
[01:29:32.178]                               data <- list(type = "VALUE", value = cond, 
[01:29:32.178]                                 success = TRUE)
[01:29:32.178]                               parallel_sendData(master, data)
[01:29:32.178]                             }
[01:29:32.178]                             return(sendCondition)
[01:29:32.178]                           }
[01:29:32.178]                         }
[01:29:32.178]                         frame <- frame + 1L
[01:29:32.178]                         envir <- sys.frame(frame)
[01:29:32.178]                       }
[01:29:32.178]                     }
[01:29:32.178]                     sendCondition <<- function(cond) NULL
[01:29:32.178]                   }
[01:29:32.178]                 })
[01:29:32.178]                 withCallingHandlers({
[01:29:32.178]                   {
[01:29:32.178]                     sample(x, size = 1L)
[01:29:32.178]                   }
[01:29:32.178]                 }, immediateCondition = function(cond) {
[01:29:32.178]                   sendCondition <- ...future.makeSendCondition()
[01:29:32.178]                   sendCondition(cond)
[01:29:32.178]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.178]                   {
[01:29:32.178]                     inherits <- base::inherits
[01:29:32.178]                     invokeRestart <- base::invokeRestart
[01:29:32.178]                     is.null <- base::is.null
[01:29:32.178]                     muffled <- FALSE
[01:29:32.178]                     if (inherits(cond, "message")) {
[01:29:32.178]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:32.178]                       if (muffled) 
[01:29:32.178]                         invokeRestart("muffleMessage")
[01:29:32.178]                     }
[01:29:32.178]                     else if (inherits(cond, "warning")) {
[01:29:32.178]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:32.178]                       if (muffled) 
[01:29:32.178]                         invokeRestart("muffleWarning")
[01:29:32.178]                     }
[01:29:32.178]                     else if (inherits(cond, "condition")) {
[01:29:32.178]                       if (!is.null(pattern)) {
[01:29:32.178]                         computeRestarts <- base::computeRestarts
[01:29:32.178]                         grepl <- base::grepl
[01:29:32.178]                         restarts <- computeRestarts(cond)
[01:29:32.178]                         for (restart in restarts) {
[01:29:32.178]                           name <- restart$name
[01:29:32.178]                           if (is.null(name)) 
[01:29:32.178]                             next
[01:29:32.178]                           if (!grepl(pattern, name)) 
[01:29:32.178]                             next
[01:29:32.178]                           invokeRestart(restart)
[01:29:32.178]                           muffled <- TRUE
[01:29:32.178]                           break
[01:29:32.178]                         }
[01:29:32.178]                       }
[01:29:32.178]                     }
[01:29:32.178]                     invisible(muffled)
[01:29:32.178]                   }
[01:29:32.178]                   muffleCondition(cond)
[01:29:32.178]                 })
[01:29:32.178]             }))
[01:29:32.178]             future::FutureResult(value = ...future.value$value, 
[01:29:32.178]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.178]                   ...future.rng), globalenv = if (FALSE) 
[01:29:32.178]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:32.178]                     ...future.globalenv.names))
[01:29:32.178]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:32.178]         }, condition = base::local({
[01:29:32.178]             c <- base::c
[01:29:32.178]             inherits <- base::inherits
[01:29:32.178]             invokeRestart <- base::invokeRestart
[01:29:32.178]             length <- base::length
[01:29:32.178]             list <- base::list
[01:29:32.178]             seq.int <- base::seq.int
[01:29:32.178]             signalCondition <- base::signalCondition
[01:29:32.178]             sys.calls <- base::sys.calls
[01:29:32.178]             `[[` <- base::`[[`
[01:29:32.178]             `+` <- base::`+`
[01:29:32.178]             `<<-` <- base::`<<-`
[01:29:32.178]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:32.178]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:32.178]                   3L)]
[01:29:32.178]             }
[01:29:32.178]             function(cond) {
[01:29:32.178]                 is_error <- inherits(cond, "error")
[01:29:32.178]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:32.178]                   NULL)
[01:29:32.178]                 if (is_error) {
[01:29:32.178]                   sessionInformation <- function() {
[01:29:32.178]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:32.178]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:32.178]                       search = base::search(), system = base::Sys.info())
[01:29:32.178]                   }
[01:29:32.178]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.178]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:32.178]                     cond$call), session = sessionInformation(), 
[01:29:32.178]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:32.178]                   signalCondition(cond)
[01:29:32.178]                 }
[01:29:32.178]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:32.178]                 "immediateCondition"))) {
[01:29:32.178]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:32.178]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.178]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:32.178]                   if (TRUE && !signal) {
[01:29:32.178]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.178]                     {
[01:29:32.178]                       inherits <- base::inherits
[01:29:32.178]                       invokeRestart <- base::invokeRestart
[01:29:32.178]                       is.null <- base::is.null
[01:29:32.178]                       muffled <- FALSE
[01:29:32.178]                       if (inherits(cond, "message")) {
[01:29:32.178]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.178]                         if (muffled) 
[01:29:32.178]                           invokeRestart("muffleMessage")
[01:29:32.178]                       }
[01:29:32.178]                       else if (inherits(cond, "warning")) {
[01:29:32.178]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.178]                         if (muffled) 
[01:29:32.178]                           invokeRestart("muffleWarning")
[01:29:32.178]                       }
[01:29:32.178]                       else if (inherits(cond, "condition")) {
[01:29:32.178]                         if (!is.null(pattern)) {
[01:29:32.178]                           computeRestarts <- base::computeRestarts
[01:29:32.178]                           grepl <- base::grepl
[01:29:32.178]                           restarts <- computeRestarts(cond)
[01:29:32.178]                           for (restart in restarts) {
[01:29:32.178]                             name <- restart$name
[01:29:32.178]                             if (is.null(name)) 
[01:29:32.178]                               next
[01:29:32.178]                             if (!grepl(pattern, name)) 
[01:29:32.178]                               next
[01:29:32.178]                             invokeRestart(restart)
[01:29:32.178]                             muffled <- TRUE
[01:29:32.178]                             break
[01:29:32.178]                           }
[01:29:32.178]                         }
[01:29:32.178]                       }
[01:29:32.178]                       invisible(muffled)
[01:29:32.178]                     }
[01:29:32.178]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.178]                   }
[01:29:32.178]                 }
[01:29:32.178]                 else {
[01:29:32.178]                   if (TRUE) {
[01:29:32.178]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.178]                     {
[01:29:32.178]                       inherits <- base::inherits
[01:29:32.178]                       invokeRestart <- base::invokeRestart
[01:29:32.178]                       is.null <- base::is.null
[01:29:32.178]                       muffled <- FALSE
[01:29:32.178]                       if (inherits(cond, "message")) {
[01:29:32.178]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.178]                         if (muffled) 
[01:29:32.178]                           invokeRestart("muffleMessage")
[01:29:32.178]                       }
[01:29:32.178]                       else if (inherits(cond, "warning")) {
[01:29:32.178]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.178]                         if (muffled) 
[01:29:32.178]                           invokeRestart("muffleWarning")
[01:29:32.178]                       }
[01:29:32.178]                       else if (inherits(cond, "condition")) {
[01:29:32.178]                         if (!is.null(pattern)) {
[01:29:32.178]                           computeRestarts <- base::computeRestarts
[01:29:32.178]                           grepl <- base::grepl
[01:29:32.178]                           restarts <- computeRestarts(cond)
[01:29:32.178]                           for (restart in restarts) {
[01:29:32.178]                             name <- restart$name
[01:29:32.178]                             if (is.null(name)) 
[01:29:32.178]                               next
[01:29:32.178]                             if (!grepl(pattern, name)) 
[01:29:32.178]                               next
[01:29:32.178]                             invokeRestart(restart)
[01:29:32.178]                             muffled <- TRUE
[01:29:32.178]                             break
[01:29:32.178]                           }
[01:29:32.178]                         }
[01:29:32.178]                       }
[01:29:32.178]                       invisible(muffled)
[01:29:32.178]                     }
[01:29:32.178]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.178]                   }
[01:29:32.178]                 }
[01:29:32.178]             }
[01:29:32.178]         }))
[01:29:32.178]     }, error = function(ex) {
[01:29:32.178]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:32.178]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.178]                 ...future.rng), started = ...future.startTime, 
[01:29:32.178]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:32.178]             version = "1.8"), class = "FutureResult")
[01:29:32.178]     }, finally = {
[01:29:32.178]         if (!identical(...future.workdir, getwd())) 
[01:29:32.178]             setwd(...future.workdir)
[01:29:32.178]         {
[01:29:32.178]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:32.178]                 ...future.oldOptions$nwarnings <- NULL
[01:29:32.178]             }
[01:29:32.178]             base::options(...future.oldOptions)
[01:29:32.178]             if (.Platform$OS.type == "windows") {
[01:29:32.178]                 old_names <- names(...future.oldEnvVars)
[01:29:32.178]                 envs <- base::Sys.getenv()
[01:29:32.178]                 names <- names(envs)
[01:29:32.178]                 common <- intersect(names, old_names)
[01:29:32.178]                 added <- setdiff(names, old_names)
[01:29:32.178]                 removed <- setdiff(old_names, names)
[01:29:32.178]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:32.178]                   envs[common]]
[01:29:32.178]                 NAMES <- toupper(changed)
[01:29:32.178]                 args <- list()
[01:29:32.178]                 for (kk in seq_along(NAMES)) {
[01:29:32.178]                   name <- changed[[kk]]
[01:29:32.178]                   NAME <- NAMES[[kk]]
[01:29:32.178]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.178]                     next
[01:29:32.178]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.178]                 }
[01:29:32.178]                 NAMES <- toupper(added)
[01:29:32.178]                 for (kk in seq_along(NAMES)) {
[01:29:32.178]                   name <- added[[kk]]
[01:29:32.178]                   NAME <- NAMES[[kk]]
[01:29:32.178]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.178]                     next
[01:29:32.178]                   args[[name]] <- ""
[01:29:32.178]                 }
[01:29:32.178]                 NAMES <- toupper(removed)
[01:29:32.178]                 for (kk in seq_along(NAMES)) {
[01:29:32.178]                   name <- removed[[kk]]
[01:29:32.178]                   NAME <- NAMES[[kk]]
[01:29:32.178]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.178]                     next
[01:29:32.178]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.178]                 }
[01:29:32.178]                 if (length(args) > 0) 
[01:29:32.178]                   base::do.call(base::Sys.setenv, args = args)
[01:29:32.178]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:32.178]             }
[01:29:32.178]             else {
[01:29:32.178]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:32.178]             }
[01:29:32.178]             {
[01:29:32.178]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:32.178]                   0L) {
[01:29:32.178]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:32.178]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:32.178]                   base::options(opts)
[01:29:32.178]                 }
[01:29:32.178]                 {
[01:29:32.178]                   {
[01:29:32.178]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:32.178]                     NULL
[01:29:32.178]                   }
[01:29:32.178]                   options(future.plan = NULL)
[01:29:32.178]                   if (is.na(NA_character_)) 
[01:29:32.178]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.178]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:32.178]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:32.178]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:32.178]                     envir = parent.frame()) 
[01:29:32.178]                   {
[01:29:32.178]                     if (is.function(workers)) 
[01:29:32.178]                       workers <- workers()
[01:29:32.178]                     workers <- structure(as.integer(workers), 
[01:29:32.178]                       class = class(workers))
[01:29:32.178]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:32.178]                       workers >= 1)
[01:29:32.178]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:32.178]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:32.178]                     }
[01:29:32.178]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:32.178]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:32.178]                       envir = envir)
[01:29:32.178]                     if (!future$lazy) 
[01:29:32.178]                       future <- run(future)
[01:29:32.178]                     invisible(future)
[01:29:32.178]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:32.178]                 }
[01:29:32.178]             }
[01:29:32.178]         }
[01:29:32.178]     })
[01:29:32.178]     if (TRUE) {
[01:29:32.178]         base::sink(type = "output", split = FALSE)
[01:29:32.178]         if (TRUE) {
[01:29:32.178]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:32.178]         }
[01:29:32.178]         else {
[01:29:32.178]             ...future.result["stdout"] <- base::list(NULL)
[01:29:32.178]         }
[01:29:32.178]         base::close(...future.stdout)
[01:29:32.178]         ...future.stdout <- NULL
[01:29:32.178]     }
[01:29:32.178]     ...future.result$conditions <- ...future.conditions
[01:29:32.178]     ...future.result$finished <- base::Sys.time()
[01:29:32.178]     ...future.result
[01:29:32.178] }
[01:29:32.183] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:32.206] receiveMessageFromWorker() for ClusterFuture ...
[01:29:32.206] - Validating connection of MultisessionFuture
[01:29:32.206] - received message: FutureResult
[01:29:32.207] - Received FutureResult
[01:29:32.207] - Erased future from FutureRegistry
[01:29:32.207] result() for ClusterFuture ...
[01:29:32.207] - result already collected: FutureResult
[01:29:32.207] result() for ClusterFuture ... done
[01:29:32.208] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:32.208] result() for ClusterFuture ...
[01:29:32.208] - result already collected: FutureResult
[01:29:32.208] result() for ClusterFuture ... done
[01:29:32.208] result() for ClusterFuture ...
[01:29:32.208] - result already collected: FutureResult
[01:29:32.209] result() for ClusterFuture ... done
[01:29:32.210] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:32.210] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:32.210] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:32.210] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:32.211] MultisessionFuture started
[01:29:32.211] - Launch lazy future ... done
[01:29:32.212] run() for 'MultisessionFuture' ... done
[01:29:32.212] result() for ClusterFuture ...
[01:29:32.212] - result already collected: FutureResult
[01:29:32.212] result() for ClusterFuture ... done
[01:29:32.212] result() for ClusterFuture ...
[01:29:32.213] - result already collected: FutureResult
[01:29:32.213] result() for ClusterFuture ... done
[01:29:32.213] result() for ClusterFuture ...
[01:29:32.213] - result already collected: FutureResult
[01:29:32.213] result() for ClusterFuture ... done
[01:29:32.214] result() for ClusterFuture ...
[01:29:32.214] - result already collected: FutureResult
[01:29:32.214] result() for ClusterFuture ... done
[01:29:32.214] result() for ClusterFuture ...
[01:29:32.214] receiveMessageFromWorker() for ClusterFuture ...
[01:29:32.215] - Validating connection of MultisessionFuture
[01:29:32.215] - received message: FutureResult
[01:29:32.215] - Received FutureResult
[01:29:32.215] - Erased future from FutureRegistry
[01:29:32.215] result() for ClusterFuture ...
[01:29:32.216] - result already collected: FutureResult
[01:29:32.216] result() for ClusterFuture ... done
[01:29:32.216] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:32.216] result() for ClusterFuture ... done
[01:29:32.216] result() for ClusterFuture ...
[01:29:32.216] - result already collected: FutureResult
[01:29:32.217] result() for ClusterFuture ... done
[01:29:32.217] result() for ClusterFuture ...
[01:29:32.217] receiveMessageFromWorker() for ClusterFuture ...
[01:29:32.217] - Validating connection of MultisessionFuture
[01:29:32.229] - received message: FutureResult
[01:29:32.229] - Received FutureResult
[01:29:32.229] - Erased future from FutureRegistry
[01:29:32.229] result() for ClusterFuture ...
[01:29:32.230] - result already collected: FutureResult
[01:29:32.230] result() for ClusterFuture ... done
[01:29:32.230] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:32.230] result() for ClusterFuture ... done
[01:29:32.230] result() for ClusterFuture ...
[01:29:32.230] - result already collected: FutureResult
[01:29:32.230] result() for ClusterFuture ... done
[[1]]
[1] 3

[[2]]
[1] 0

[[3]]
[1] 1

[[4]]
[1] 1

[01:29:32.231] getGlobalsAndPackages() ...
[01:29:32.232] Searching for globals...
[01:29:32.233] - globals found: [3] '{', 'sample', 'x'
[01:29:32.233] Searching for globals ... DONE
[01:29:32.233] Resolving globals: FALSE
[01:29:32.234] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:32.234] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:32.234] - globals: [1] 'x'
[01:29:32.235] 
[01:29:32.235] getGlobalsAndPackages() ... DONE
[01:29:32.235] run() for 'Future' ...
[01:29:32.235] - state: 'created'
[01:29:32.235] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:32.250] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:32.250] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:32.250]   - Field: 'node'
[01:29:32.250]   - Field: 'label'
[01:29:32.251]   - Field: 'local'
[01:29:32.251]   - Field: 'owner'
[01:29:32.251]   - Field: 'envir'
[01:29:32.251]   - Field: 'workers'
[01:29:32.251]   - Field: 'packages'
[01:29:32.251]   - Field: 'gc'
[01:29:32.252]   - Field: 'conditions'
[01:29:32.252]   - Field: 'persistent'
[01:29:32.252]   - Field: 'expr'
[01:29:32.252]   - Field: 'uuid'
[01:29:32.252]   - Field: 'seed'
[01:29:32.253]   - Field: 'version'
[01:29:32.253]   - Field: 'result'
[01:29:32.253]   - Field: 'asynchronous'
[01:29:32.253]   - Field: 'calls'
[01:29:32.253]   - Field: 'globals'
[01:29:32.253]   - Field: 'stdout'
[01:29:32.254]   - Field: 'earlySignal'
[01:29:32.254]   - Field: 'lazy'
[01:29:32.254]   - Field: 'state'
[01:29:32.254] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:32.254] - Launch lazy future ...
[01:29:32.255] Packages needed by the future expression (n = 0): <none>
[01:29:32.255] Packages needed by future strategies (n = 0): <none>
[01:29:32.256] {
[01:29:32.256]     {
[01:29:32.256]         {
[01:29:32.256]             ...future.startTime <- base::Sys.time()
[01:29:32.256]             {
[01:29:32.256]                 {
[01:29:32.256]                   {
[01:29:32.256]                     {
[01:29:32.256]                       base::local({
[01:29:32.256]                         has_future <- base::requireNamespace("future", 
[01:29:32.256]                           quietly = TRUE)
[01:29:32.256]                         if (has_future) {
[01:29:32.256]                           ns <- base::getNamespace("future")
[01:29:32.256]                           version <- ns[[".package"]][["version"]]
[01:29:32.256]                           if (is.null(version)) 
[01:29:32.256]                             version <- utils::packageVersion("future")
[01:29:32.256]                         }
[01:29:32.256]                         else {
[01:29:32.256]                           version <- NULL
[01:29:32.256]                         }
[01:29:32.256]                         if (!has_future || version < "1.8.0") {
[01:29:32.256]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:32.256]                             "", base::R.version$version.string), 
[01:29:32.256]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:32.256]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:32.256]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:32.256]                               "release", "version")], collapse = " "), 
[01:29:32.256]                             hostname = base::Sys.info()[["nodename"]])
[01:29:32.256]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:32.256]                             info)
[01:29:32.256]                           info <- base::paste(info, collapse = "; ")
[01:29:32.256]                           if (!has_future) {
[01:29:32.256]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:32.256]                               info)
[01:29:32.256]                           }
[01:29:32.256]                           else {
[01:29:32.256]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:32.256]                               info, version)
[01:29:32.256]                           }
[01:29:32.256]                           base::stop(msg)
[01:29:32.256]                         }
[01:29:32.256]                       })
[01:29:32.256]                     }
[01:29:32.256]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:32.256]                     base::options(mc.cores = 1L)
[01:29:32.256]                   }
[01:29:32.256]                   options(future.plan = NULL)
[01:29:32.256]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.256]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:32.256]                 }
[01:29:32.256]                 ...future.workdir <- getwd()
[01:29:32.256]             }
[01:29:32.256]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:32.256]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:32.256]         }
[01:29:32.256]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:32.256]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:32.256]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:32.256]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:32.256]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:32.256]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:32.256]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:32.256]             base::names(...future.oldOptions))
[01:29:32.256]     }
[01:29:32.256]     if (FALSE) {
[01:29:32.256]     }
[01:29:32.256]     else {
[01:29:32.256]         if (TRUE) {
[01:29:32.256]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:32.256]                 open = "w")
[01:29:32.256]         }
[01:29:32.256]         else {
[01:29:32.256]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:32.256]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:32.256]         }
[01:29:32.256]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:32.256]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:32.256]             base::sink(type = "output", split = FALSE)
[01:29:32.256]             base::close(...future.stdout)
[01:29:32.256]         }, add = TRUE)
[01:29:32.256]     }
[01:29:32.256]     ...future.frame <- base::sys.nframe()
[01:29:32.256]     ...future.conditions <- base::list()
[01:29:32.256]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:32.256]     if (FALSE) {
[01:29:32.256]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:32.256]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:32.256]     }
[01:29:32.256]     ...future.result <- base::tryCatch({
[01:29:32.256]         base::withCallingHandlers({
[01:29:32.256]             ...future.value <- base::withVisible(base::local({
[01:29:32.256]                 ...future.makeSendCondition <- base::local({
[01:29:32.256]                   sendCondition <- NULL
[01:29:32.256]                   function(frame = 1L) {
[01:29:32.256]                     if (is.function(sendCondition)) 
[01:29:32.256]                       return(sendCondition)
[01:29:32.256]                     ns <- getNamespace("parallel")
[01:29:32.256]                     if (exists("sendData", mode = "function", 
[01:29:32.256]                       envir = ns)) {
[01:29:32.256]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:32.256]                         envir = ns)
[01:29:32.256]                       envir <- sys.frame(frame)
[01:29:32.256]                       master <- NULL
[01:29:32.256]                       while (!identical(envir, .GlobalEnv) && 
[01:29:32.256]                         !identical(envir, emptyenv())) {
[01:29:32.256]                         if (exists("master", mode = "list", envir = envir, 
[01:29:32.256]                           inherits = FALSE)) {
[01:29:32.256]                           master <- get("master", mode = "list", 
[01:29:32.256]                             envir = envir, inherits = FALSE)
[01:29:32.256]                           if (inherits(master, c("SOCKnode", 
[01:29:32.256]                             "SOCK0node"))) {
[01:29:32.256]                             sendCondition <<- function(cond) {
[01:29:32.256]                               data <- list(type = "VALUE", value = cond, 
[01:29:32.256]                                 success = TRUE)
[01:29:32.256]                               parallel_sendData(master, data)
[01:29:32.256]                             }
[01:29:32.256]                             return(sendCondition)
[01:29:32.256]                           }
[01:29:32.256]                         }
[01:29:32.256]                         frame <- frame + 1L
[01:29:32.256]                         envir <- sys.frame(frame)
[01:29:32.256]                       }
[01:29:32.256]                     }
[01:29:32.256]                     sendCondition <<- function(cond) NULL
[01:29:32.256]                   }
[01:29:32.256]                 })
[01:29:32.256]                 withCallingHandlers({
[01:29:32.256]                   {
[01:29:32.256]                     sample(x, size = 1L)
[01:29:32.256]                   }
[01:29:32.256]                 }, immediateCondition = function(cond) {
[01:29:32.256]                   sendCondition <- ...future.makeSendCondition()
[01:29:32.256]                   sendCondition(cond)
[01:29:32.256]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.256]                   {
[01:29:32.256]                     inherits <- base::inherits
[01:29:32.256]                     invokeRestart <- base::invokeRestart
[01:29:32.256]                     is.null <- base::is.null
[01:29:32.256]                     muffled <- FALSE
[01:29:32.256]                     if (inherits(cond, "message")) {
[01:29:32.256]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:32.256]                       if (muffled) 
[01:29:32.256]                         invokeRestart("muffleMessage")
[01:29:32.256]                     }
[01:29:32.256]                     else if (inherits(cond, "warning")) {
[01:29:32.256]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:32.256]                       if (muffled) 
[01:29:32.256]                         invokeRestart("muffleWarning")
[01:29:32.256]                     }
[01:29:32.256]                     else if (inherits(cond, "condition")) {
[01:29:32.256]                       if (!is.null(pattern)) {
[01:29:32.256]                         computeRestarts <- base::computeRestarts
[01:29:32.256]                         grepl <- base::grepl
[01:29:32.256]                         restarts <- computeRestarts(cond)
[01:29:32.256]                         for (restart in restarts) {
[01:29:32.256]                           name <- restart$name
[01:29:32.256]                           if (is.null(name)) 
[01:29:32.256]                             next
[01:29:32.256]                           if (!grepl(pattern, name)) 
[01:29:32.256]                             next
[01:29:32.256]                           invokeRestart(restart)
[01:29:32.256]                           muffled <- TRUE
[01:29:32.256]                           break
[01:29:32.256]                         }
[01:29:32.256]                       }
[01:29:32.256]                     }
[01:29:32.256]                     invisible(muffled)
[01:29:32.256]                   }
[01:29:32.256]                   muffleCondition(cond)
[01:29:32.256]                 })
[01:29:32.256]             }))
[01:29:32.256]             future::FutureResult(value = ...future.value$value, 
[01:29:32.256]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.256]                   ...future.rng), globalenv = if (FALSE) 
[01:29:32.256]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:32.256]                     ...future.globalenv.names))
[01:29:32.256]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:32.256]         }, condition = base::local({
[01:29:32.256]             c <- base::c
[01:29:32.256]             inherits <- base::inherits
[01:29:32.256]             invokeRestart <- base::invokeRestart
[01:29:32.256]             length <- base::length
[01:29:32.256]             list <- base::list
[01:29:32.256]             seq.int <- base::seq.int
[01:29:32.256]             signalCondition <- base::signalCondition
[01:29:32.256]             sys.calls <- base::sys.calls
[01:29:32.256]             `[[` <- base::`[[`
[01:29:32.256]             `+` <- base::`+`
[01:29:32.256]             `<<-` <- base::`<<-`
[01:29:32.256]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:32.256]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:32.256]                   3L)]
[01:29:32.256]             }
[01:29:32.256]             function(cond) {
[01:29:32.256]                 is_error <- inherits(cond, "error")
[01:29:32.256]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:32.256]                   NULL)
[01:29:32.256]                 if (is_error) {
[01:29:32.256]                   sessionInformation <- function() {
[01:29:32.256]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:32.256]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:32.256]                       search = base::search(), system = base::Sys.info())
[01:29:32.256]                   }
[01:29:32.256]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.256]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:32.256]                     cond$call), session = sessionInformation(), 
[01:29:32.256]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:32.256]                   signalCondition(cond)
[01:29:32.256]                 }
[01:29:32.256]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:32.256]                 "immediateCondition"))) {
[01:29:32.256]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:32.256]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.256]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:32.256]                   if (TRUE && !signal) {
[01:29:32.256]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.256]                     {
[01:29:32.256]                       inherits <- base::inherits
[01:29:32.256]                       invokeRestart <- base::invokeRestart
[01:29:32.256]                       is.null <- base::is.null
[01:29:32.256]                       muffled <- FALSE
[01:29:32.256]                       if (inherits(cond, "message")) {
[01:29:32.256]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.256]                         if (muffled) 
[01:29:32.256]                           invokeRestart("muffleMessage")
[01:29:32.256]                       }
[01:29:32.256]                       else if (inherits(cond, "warning")) {
[01:29:32.256]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.256]                         if (muffled) 
[01:29:32.256]                           invokeRestart("muffleWarning")
[01:29:32.256]                       }
[01:29:32.256]                       else if (inherits(cond, "condition")) {
[01:29:32.256]                         if (!is.null(pattern)) {
[01:29:32.256]                           computeRestarts <- base::computeRestarts
[01:29:32.256]                           grepl <- base::grepl
[01:29:32.256]                           restarts <- computeRestarts(cond)
[01:29:32.256]                           for (restart in restarts) {
[01:29:32.256]                             name <- restart$name
[01:29:32.256]                             if (is.null(name)) 
[01:29:32.256]                               next
[01:29:32.256]                             if (!grepl(pattern, name)) 
[01:29:32.256]                               next
[01:29:32.256]                             invokeRestart(restart)
[01:29:32.256]                             muffled <- TRUE
[01:29:32.256]                             break
[01:29:32.256]                           }
[01:29:32.256]                         }
[01:29:32.256]                       }
[01:29:32.256]                       invisible(muffled)
[01:29:32.256]                     }
[01:29:32.256]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.256]                   }
[01:29:32.256]                 }
[01:29:32.256]                 else {
[01:29:32.256]                   if (TRUE) {
[01:29:32.256]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.256]                     {
[01:29:32.256]                       inherits <- base::inherits
[01:29:32.256]                       invokeRestart <- base::invokeRestart
[01:29:32.256]                       is.null <- base::is.null
[01:29:32.256]                       muffled <- FALSE
[01:29:32.256]                       if (inherits(cond, "message")) {
[01:29:32.256]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.256]                         if (muffled) 
[01:29:32.256]                           invokeRestart("muffleMessage")
[01:29:32.256]                       }
[01:29:32.256]                       else if (inherits(cond, "warning")) {
[01:29:32.256]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.256]                         if (muffled) 
[01:29:32.256]                           invokeRestart("muffleWarning")
[01:29:32.256]                       }
[01:29:32.256]                       else if (inherits(cond, "condition")) {
[01:29:32.256]                         if (!is.null(pattern)) {
[01:29:32.256]                           computeRestarts <- base::computeRestarts
[01:29:32.256]                           grepl <- base::grepl
[01:29:32.256]                           restarts <- computeRestarts(cond)
[01:29:32.256]                           for (restart in restarts) {
[01:29:32.256]                             name <- restart$name
[01:29:32.256]                             if (is.null(name)) 
[01:29:32.256]                               next
[01:29:32.256]                             if (!grepl(pattern, name)) 
[01:29:32.256]                               next
[01:29:32.256]                             invokeRestart(restart)
[01:29:32.256]                             muffled <- TRUE
[01:29:32.256]                             break
[01:29:32.256]                           }
[01:29:32.256]                         }
[01:29:32.256]                       }
[01:29:32.256]                       invisible(muffled)
[01:29:32.256]                     }
[01:29:32.256]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.256]                   }
[01:29:32.256]                 }
[01:29:32.256]             }
[01:29:32.256]         }))
[01:29:32.256]     }, error = function(ex) {
[01:29:32.256]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:32.256]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.256]                 ...future.rng), started = ...future.startTime, 
[01:29:32.256]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:32.256]             version = "1.8"), class = "FutureResult")
[01:29:32.256]     }, finally = {
[01:29:32.256]         if (!identical(...future.workdir, getwd())) 
[01:29:32.256]             setwd(...future.workdir)
[01:29:32.256]         {
[01:29:32.256]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:32.256]                 ...future.oldOptions$nwarnings <- NULL
[01:29:32.256]             }
[01:29:32.256]             base::options(...future.oldOptions)
[01:29:32.256]             if (.Platform$OS.type == "windows") {
[01:29:32.256]                 old_names <- names(...future.oldEnvVars)
[01:29:32.256]                 envs <- base::Sys.getenv()
[01:29:32.256]                 names <- names(envs)
[01:29:32.256]                 common <- intersect(names, old_names)
[01:29:32.256]                 added <- setdiff(names, old_names)
[01:29:32.256]                 removed <- setdiff(old_names, names)
[01:29:32.256]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:32.256]                   envs[common]]
[01:29:32.256]                 NAMES <- toupper(changed)
[01:29:32.256]                 args <- list()
[01:29:32.256]                 for (kk in seq_along(NAMES)) {
[01:29:32.256]                   name <- changed[[kk]]
[01:29:32.256]                   NAME <- NAMES[[kk]]
[01:29:32.256]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.256]                     next
[01:29:32.256]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.256]                 }
[01:29:32.256]                 NAMES <- toupper(added)
[01:29:32.256]                 for (kk in seq_along(NAMES)) {
[01:29:32.256]                   name <- added[[kk]]
[01:29:32.256]                   NAME <- NAMES[[kk]]
[01:29:32.256]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.256]                     next
[01:29:32.256]                   args[[name]] <- ""
[01:29:32.256]                 }
[01:29:32.256]                 NAMES <- toupper(removed)
[01:29:32.256]                 for (kk in seq_along(NAMES)) {
[01:29:32.256]                   name <- removed[[kk]]
[01:29:32.256]                   NAME <- NAMES[[kk]]
[01:29:32.256]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.256]                     next
[01:29:32.256]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.256]                 }
[01:29:32.256]                 if (length(args) > 0) 
[01:29:32.256]                   base::do.call(base::Sys.setenv, args = args)
[01:29:32.256]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:32.256]             }
[01:29:32.256]             else {
[01:29:32.256]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:32.256]             }
[01:29:32.256]             {
[01:29:32.256]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:32.256]                   0L) {
[01:29:32.256]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:32.256]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:32.256]                   base::options(opts)
[01:29:32.256]                 }
[01:29:32.256]                 {
[01:29:32.256]                   {
[01:29:32.256]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:32.256]                     NULL
[01:29:32.256]                   }
[01:29:32.256]                   options(future.plan = NULL)
[01:29:32.256]                   if (is.na(NA_character_)) 
[01:29:32.256]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.256]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:32.256]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:32.256]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:32.256]                     envir = parent.frame()) 
[01:29:32.256]                   {
[01:29:32.256]                     if (is.function(workers)) 
[01:29:32.256]                       workers <- workers()
[01:29:32.256]                     workers <- structure(as.integer(workers), 
[01:29:32.256]                       class = class(workers))
[01:29:32.256]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:32.256]                       workers >= 1)
[01:29:32.256]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:32.256]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:32.256]                     }
[01:29:32.256]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:32.256]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:32.256]                       envir = envir)
[01:29:32.256]                     if (!future$lazy) 
[01:29:32.256]                       future <- run(future)
[01:29:32.256]                     invisible(future)
[01:29:32.256]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:32.256]                 }
[01:29:32.256]             }
[01:29:32.256]         }
[01:29:32.256]     })
[01:29:32.256]     if (TRUE) {
[01:29:32.256]         base::sink(type = "output", split = FALSE)
[01:29:32.256]         if (TRUE) {
[01:29:32.256]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:32.256]         }
[01:29:32.256]         else {
[01:29:32.256]             ...future.result["stdout"] <- base::list(NULL)
[01:29:32.256]         }
[01:29:32.256]         base::close(...future.stdout)
[01:29:32.256]         ...future.stdout <- NULL
[01:29:32.256]     }
[01:29:32.256]     ...future.result$conditions <- ...future.conditions
[01:29:32.256]     ...future.result$finished <- base::Sys.time()
[01:29:32.256]     ...future.result
[01:29:32.256] }
[01:29:32.261] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:32.261] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:32.262] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:32.262] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:32.263] MultisessionFuture started
[01:29:32.263] - Launch lazy future ... done
[01:29:32.263] run() for 'MultisessionFuture' ... done
[01:29:32.264] getGlobalsAndPackages() ...
[01:29:32.264] Searching for globals...
[01:29:32.265] - globals found: [3] '{', 'sample', 'x'
[01:29:32.266] Searching for globals ... DONE
[01:29:32.266] Resolving globals: FALSE
[01:29:32.266] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:32.267] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:32.267] - globals: [1] 'x'
[01:29:32.267] 
[01:29:32.267] getGlobalsAndPackages() ... DONE
[01:29:32.268] run() for 'Future' ...
[01:29:32.268] - state: 'created'
[01:29:32.268] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:32.287] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:32.287] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:32.287]   - Field: 'node'
[01:29:32.288]   - Field: 'label'
[01:29:32.288]   - Field: 'local'
[01:29:32.288]   - Field: 'owner'
[01:29:32.288]   - Field: 'envir'
[01:29:32.288]   - Field: 'workers'
[01:29:32.289]   - Field: 'packages'
[01:29:32.289]   - Field: 'gc'
[01:29:32.289]   - Field: 'conditions'
[01:29:32.289]   - Field: 'persistent'
[01:29:32.289]   - Field: 'expr'
[01:29:32.289]   - Field: 'uuid'
[01:29:32.290]   - Field: 'seed'
[01:29:32.290]   - Field: 'version'
[01:29:32.290]   - Field: 'result'
[01:29:32.290]   - Field: 'asynchronous'
[01:29:32.290]   - Field: 'calls'
[01:29:32.290]   - Field: 'globals'
[01:29:32.291]   - Field: 'stdout'
[01:29:32.291]   - Field: 'earlySignal'
[01:29:32.291]   - Field: 'lazy'
[01:29:32.291]   - Field: 'state'
[01:29:32.291] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:32.292] - Launch lazy future ...
[01:29:32.292] Packages needed by the future expression (n = 0): <none>
[01:29:32.292] Packages needed by future strategies (n = 0): <none>
[01:29:32.293] {
[01:29:32.293]     {
[01:29:32.293]         {
[01:29:32.293]             ...future.startTime <- base::Sys.time()
[01:29:32.293]             {
[01:29:32.293]                 {
[01:29:32.293]                   {
[01:29:32.293]                     {
[01:29:32.293]                       base::local({
[01:29:32.293]                         has_future <- base::requireNamespace("future", 
[01:29:32.293]                           quietly = TRUE)
[01:29:32.293]                         if (has_future) {
[01:29:32.293]                           ns <- base::getNamespace("future")
[01:29:32.293]                           version <- ns[[".package"]][["version"]]
[01:29:32.293]                           if (is.null(version)) 
[01:29:32.293]                             version <- utils::packageVersion("future")
[01:29:32.293]                         }
[01:29:32.293]                         else {
[01:29:32.293]                           version <- NULL
[01:29:32.293]                         }
[01:29:32.293]                         if (!has_future || version < "1.8.0") {
[01:29:32.293]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:32.293]                             "", base::R.version$version.string), 
[01:29:32.293]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:32.293]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:32.293]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:32.293]                               "release", "version")], collapse = " "), 
[01:29:32.293]                             hostname = base::Sys.info()[["nodename"]])
[01:29:32.293]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:32.293]                             info)
[01:29:32.293]                           info <- base::paste(info, collapse = "; ")
[01:29:32.293]                           if (!has_future) {
[01:29:32.293]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:32.293]                               info)
[01:29:32.293]                           }
[01:29:32.293]                           else {
[01:29:32.293]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:32.293]                               info, version)
[01:29:32.293]                           }
[01:29:32.293]                           base::stop(msg)
[01:29:32.293]                         }
[01:29:32.293]                       })
[01:29:32.293]                     }
[01:29:32.293]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:32.293]                     base::options(mc.cores = 1L)
[01:29:32.293]                   }
[01:29:32.293]                   options(future.plan = NULL)
[01:29:32.293]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.293]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:32.293]                 }
[01:29:32.293]                 ...future.workdir <- getwd()
[01:29:32.293]             }
[01:29:32.293]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:32.293]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:32.293]         }
[01:29:32.293]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:32.293]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:32.293]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:32.293]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:32.293]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:32.293]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:32.293]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:32.293]             base::names(...future.oldOptions))
[01:29:32.293]     }
[01:29:32.293]     if (FALSE) {
[01:29:32.293]     }
[01:29:32.293]     else {
[01:29:32.293]         if (TRUE) {
[01:29:32.293]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:32.293]                 open = "w")
[01:29:32.293]         }
[01:29:32.293]         else {
[01:29:32.293]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:32.293]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:32.293]         }
[01:29:32.293]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:32.293]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:32.293]             base::sink(type = "output", split = FALSE)
[01:29:32.293]             base::close(...future.stdout)
[01:29:32.293]         }, add = TRUE)
[01:29:32.293]     }
[01:29:32.293]     ...future.frame <- base::sys.nframe()
[01:29:32.293]     ...future.conditions <- base::list()
[01:29:32.293]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:32.293]     if (FALSE) {
[01:29:32.293]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:32.293]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:32.293]     }
[01:29:32.293]     ...future.result <- base::tryCatch({
[01:29:32.293]         base::withCallingHandlers({
[01:29:32.293]             ...future.value <- base::withVisible(base::local({
[01:29:32.293]                 ...future.makeSendCondition <- base::local({
[01:29:32.293]                   sendCondition <- NULL
[01:29:32.293]                   function(frame = 1L) {
[01:29:32.293]                     if (is.function(sendCondition)) 
[01:29:32.293]                       return(sendCondition)
[01:29:32.293]                     ns <- getNamespace("parallel")
[01:29:32.293]                     if (exists("sendData", mode = "function", 
[01:29:32.293]                       envir = ns)) {
[01:29:32.293]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:32.293]                         envir = ns)
[01:29:32.293]                       envir <- sys.frame(frame)
[01:29:32.293]                       master <- NULL
[01:29:32.293]                       while (!identical(envir, .GlobalEnv) && 
[01:29:32.293]                         !identical(envir, emptyenv())) {
[01:29:32.293]                         if (exists("master", mode = "list", envir = envir, 
[01:29:32.293]                           inherits = FALSE)) {
[01:29:32.293]                           master <- get("master", mode = "list", 
[01:29:32.293]                             envir = envir, inherits = FALSE)
[01:29:32.293]                           if (inherits(master, c("SOCKnode", 
[01:29:32.293]                             "SOCK0node"))) {
[01:29:32.293]                             sendCondition <<- function(cond) {
[01:29:32.293]                               data <- list(type = "VALUE", value = cond, 
[01:29:32.293]                                 success = TRUE)
[01:29:32.293]                               parallel_sendData(master, data)
[01:29:32.293]                             }
[01:29:32.293]                             return(sendCondition)
[01:29:32.293]                           }
[01:29:32.293]                         }
[01:29:32.293]                         frame <- frame + 1L
[01:29:32.293]                         envir <- sys.frame(frame)
[01:29:32.293]                       }
[01:29:32.293]                     }
[01:29:32.293]                     sendCondition <<- function(cond) NULL
[01:29:32.293]                   }
[01:29:32.293]                 })
[01:29:32.293]                 withCallingHandlers({
[01:29:32.293]                   {
[01:29:32.293]                     sample(x, size = 1L)
[01:29:32.293]                   }
[01:29:32.293]                 }, immediateCondition = function(cond) {
[01:29:32.293]                   sendCondition <- ...future.makeSendCondition()
[01:29:32.293]                   sendCondition(cond)
[01:29:32.293]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.293]                   {
[01:29:32.293]                     inherits <- base::inherits
[01:29:32.293]                     invokeRestart <- base::invokeRestart
[01:29:32.293]                     is.null <- base::is.null
[01:29:32.293]                     muffled <- FALSE
[01:29:32.293]                     if (inherits(cond, "message")) {
[01:29:32.293]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:32.293]                       if (muffled) 
[01:29:32.293]                         invokeRestart("muffleMessage")
[01:29:32.293]                     }
[01:29:32.293]                     else if (inherits(cond, "warning")) {
[01:29:32.293]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:32.293]                       if (muffled) 
[01:29:32.293]                         invokeRestart("muffleWarning")
[01:29:32.293]                     }
[01:29:32.293]                     else if (inherits(cond, "condition")) {
[01:29:32.293]                       if (!is.null(pattern)) {
[01:29:32.293]                         computeRestarts <- base::computeRestarts
[01:29:32.293]                         grepl <- base::grepl
[01:29:32.293]                         restarts <- computeRestarts(cond)
[01:29:32.293]                         for (restart in restarts) {
[01:29:32.293]                           name <- restart$name
[01:29:32.293]                           if (is.null(name)) 
[01:29:32.293]                             next
[01:29:32.293]                           if (!grepl(pattern, name)) 
[01:29:32.293]                             next
[01:29:32.293]                           invokeRestart(restart)
[01:29:32.293]                           muffled <- TRUE
[01:29:32.293]                           break
[01:29:32.293]                         }
[01:29:32.293]                       }
[01:29:32.293]                     }
[01:29:32.293]                     invisible(muffled)
[01:29:32.293]                   }
[01:29:32.293]                   muffleCondition(cond)
[01:29:32.293]                 })
[01:29:32.293]             }))
[01:29:32.293]             future::FutureResult(value = ...future.value$value, 
[01:29:32.293]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.293]                   ...future.rng), globalenv = if (FALSE) 
[01:29:32.293]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:32.293]                     ...future.globalenv.names))
[01:29:32.293]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:32.293]         }, condition = base::local({
[01:29:32.293]             c <- base::c
[01:29:32.293]             inherits <- base::inherits
[01:29:32.293]             invokeRestart <- base::invokeRestart
[01:29:32.293]             length <- base::length
[01:29:32.293]             list <- base::list
[01:29:32.293]             seq.int <- base::seq.int
[01:29:32.293]             signalCondition <- base::signalCondition
[01:29:32.293]             sys.calls <- base::sys.calls
[01:29:32.293]             `[[` <- base::`[[`
[01:29:32.293]             `+` <- base::`+`
[01:29:32.293]             `<<-` <- base::`<<-`
[01:29:32.293]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:32.293]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:32.293]                   3L)]
[01:29:32.293]             }
[01:29:32.293]             function(cond) {
[01:29:32.293]                 is_error <- inherits(cond, "error")
[01:29:32.293]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:32.293]                   NULL)
[01:29:32.293]                 if (is_error) {
[01:29:32.293]                   sessionInformation <- function() {
[01:29:32.293]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:32.293]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:32.293]                       search = base::search(), system = base::Sys.info())
[01:29:32.293]                   }
[01:29:32.293]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.293]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:32.293]                     cond$call), session = sessionInformation(), 
[01:29:32.293]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:32.293]                   signalCondition(cond)
[01:29:32.293]                 }
[01:29:32.293]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:32.293]                 "immediateCondition"))) {
[01:29:32.293]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:32.293]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.293]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:32.293]                   if (TRUE && !signal) {
[01:29:32.293]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.293]                     {
[01:29:32.293]                       inherits <- base::inherits
[01:29:32.293]                       invokeRestart <- base::invokeRestart
[01:29:32.293]                       is.null <- base::is.null
[01:29:32.293]                       muffled <- FALSE
[01:29:32.293]                       if (inherits(cond, "message")) {
[01:29:32.293]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.293]                         if (muffled) 
[01:29:32.293]                           invokeRestart("muffleMessage")
[01:29:32.293]                       }
[01:29:32.293]                       else if (inherits(cond, "warning")) {
[01:29:32.293]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.293]                         if (muffled) 
[01:29:32.293]                           invokeRestart("muffleWarning")
[01:29:32.293]                       }
[01:29:32.293]                       else if (inherits(cond, "condition")) {
[01:29:32.293]                         if (!is.null(pattern)) {
[01:29:32.293]                           computeRestarts <- base::computeRestarts
[01:29:32.293]                           grepl <- base::grepl
[01:29:32.293]                           restarts <- computeRestarts(cond)
[01:29:32.293]                           for (restart in restarts) {
[01:29:32.293]                             name <- restart$name
[01:29:32.293]                             if (is.null(name)) 
[01:29:32.293]                               next
[01:29:32.293]                             if (!grepl(pattern, name)) 
[01:29:32.293]                               next
[01:29:32.293]                             invokeRestart(restart)
[01:29:32.293]                             muffled <- TRUE
[01:29:32.293]                             break
[01:29:32.293]                           }
[01:29:32.293]                         }
[01:29:32.293]                       }
[01:29:32.293]                       invisible(muffled)
[01:29:32.293]                     }
[01:29:32.293]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.293]                   }
[01:29:32.293]                 }
[01:29:32.293]                 else {
[01:29:32.293]                   if (TRUE) {
[01:29:32.293]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.293]                     {
[01:29:32.293]                       inherits <- base::inherits
[01:29:32.293]                       invokeRestart <- base::invokeRestart
[01:29:32.293]                       is.null <- base::is.null
[01:29:32.293]                       muffled <- FALSE
[01:29:32.293]                       if (inherits(cond, "message")) {
[01:29:32.293]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.293]                         if (muffled) 
[01:29:32.293]                           invokeRestart("muffleMessage")
[01:29:32.293]                       }
[01:29:32.293]                       else if (inherits(cond, "warning")) {
[01:29:32.293]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.293]                         if (muffled) 
[01:29:32.293]                           invokeRestart("muffleWarning")
[01:29:32.293]                       }
[01:29:32.293]                       else if (inherits(cond, "condition")) {
[01:29:32.293]                         if (!is.null(pattern)) {
[01:29:32.293]                           computeRestarts <- base::computeRestarts
[01:29:32.293]                           grepl <- base::grepl
[01:29:32.293]                           restarts <- computeRestarts(cond)
[01:29:32.293]                           for (restart in restarts) {
[01:29:32.293]                             name <- restart$name
[01:29:32.293]                             if (is.null(name)) 
[01:29:32.293]                               next
[01:29:32.293]                             if (!grepl(pattern, name)) 
[01:29:32.293]                               next
[01:29:32.293]                             invokeRestart(restart)
[01:29:32.293]                             muffled <- TRUE
[01:29:32.293]                             break
[01:29:32.293]                           }
[01:29:32.293]                         }
[01:29:32.293]                       }
[01:29:32.293]                       invisible(muffled)
[01:29:32.293]                     }
[01:29:32.293]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.293]                   }
[01:29:32.293]                 }
[01:29:32.293]             }
[01:29:32.293]         }))
[01:29:32.293]     }, error = function(ex) {
[01:29:32.293]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:32.293]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.293]                 ...future.rng), started = ...future.startTime, 
[01:29:32.293]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:32.293]             version = "1.8"), class = "FutureResult")
[01:29:32.293]     }, finally = {
[01:29:32.293]         if (!identical(...future.workdir, getwd())) 
[01:29:32.293]             setwd(...future.workdir)
[01:29:32.293]         {
[01:29:32.293]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:32.293]                 ...future.oldOptions$nwarnings <- NULL
[01:29:32.293]             }
[01:29:32.293]             base::options(...future.oldOptions)
[01:29:32.293]             if (.Platform$OS.type == "windows") {
[01:29:32.293]                 old_names <- names(...future.oldEnvVars)
[01:29:32.293]                 envs <- base::Sys.getenv()
[01:29:32.293]                 names <- names(envs)
[01:29:32.293]                 common <- intersect(names, old_names)
[01:29:32.293]                 added <- setdiff(names, old_names)
[01:29:32.293]                 removed <- setdiff(old_names, names)
[01:29:32.293]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:32.293]                   envs[common]]
[01:29:32.293]                 NAMES <- toupper(changed)
[01:29:32.293]                 args <- list()
[01:29:32.293]                 for (kk in seq_along(NAMES)) {
[01:29:32.293]                   name <- changed[[kk]]
[01:29:32.293]                   NAME <- NAMES[[kk]]
[01:29:32.293]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.293]                     next
[01:29:32.293]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.293]                 }
[01:29:32.293]                 NAMES <- toupper(added)
[01:29:32.293]                 for (kk in seq_along(NAMES)) {
[01:29:32.293]                   name <- added[[kk]]
[01:29:32.293]                   NAME <- NAMES[[kk]]
[01:29:32.293]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.293]                     next
[01:29:32.293]                   args[[name]] <- ""
[01:29:32.293]                 }
[01:29:32.293]                 NAMES <- toupper(removed)
[01:29:32.293]                 for (kk in seq_along(NAMES)) {
[01:29:32.293]                   name <- removed[[kk]]
[01:29:32.293]                   NAME <- NAMES[[kk]]
[01:29:32.293]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.293]                     next
[01:29:32.293]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.293]                 }
[01:29:32.293]                 if (length(args) > 0) 
[01:29:32.293]                   base::do.call(base::Sys.setenv, args = args)
[01:29:32.293]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:32.293]             }
[01:29:32.293]             else {
[01:29:32.293]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:32.293]             }
[01:29:32.293]             {
[01:29:32.293]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:32.293]                   0L) {
[01:29:32.293]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:32.293]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:32.293]                   base::options(opts)
[01:29:32.293]                 }
[01:29:32.293]                 {
[01:29:32.293]                   {
[01:29:32.293]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:32.293]                     NULL
[01:29:32.293]                   }
[01:29:32.293]                   options(future.plan = NULL)
[01:29:32.293]                   if (is.na(NA_character_)) 
[01:29:32.293]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.293]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:32.293]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:32.293]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:32.293]                     envir = parent.frame()) 
[01:29:32.293]                   {
[01:29:32.293]                     if (is.function(workers)) 
[01:29:32.293]                       workers <- workers()
[01:29:32.293]                     workers <- structure(as.integer(workers), 
[01:29:32.293]                       class = class(workers))
[01:29:32.293]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:32.293]                       workers >= 1)
[01:29:32.293]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:32.293]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:32.293]                     }
[01:29:32.293]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:32.293]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:32.293]                       envir = envir)
[01:29:32.293]                     if (!future$lazy) 
[01:29:32.293]                       future <- run(future)
[01:29:32.293]                     invisible(future)
[01:29:32.293]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:32.293]                 }
[01:29:32.293]             }
[01:29:32.293]         }
[01:29:32.293]     })
[01:29:32.293]     if (TRUE) {
[01:29:32.293]         base::sink(type = "output", split = FALSE)
[01:29:32.293]         if (TRUE) {
[01:29:32.293]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:32.293]         }
[01:29:32.293]         else {
[01:29:32.293]             ...future.result["stdout"] <- base::list(NULL)
[01:29:32.293]         }
[01:29:32.293]         base::close(...future.stdout)
[01:29:32.293]         ...future.stdout <- NULL
[01:29:32.293]     }
[01:29:32.293]     ...future.result$conditions <- ...future.conditions
[01:29:32.293]     ...future.result$finished <- base::Sys.time()
[01:29:32.293]     ...future.result
[01:29:32.293] }
[01:29:32.298] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:32.298] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:32.299] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:32.299] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:32.300] MultisessionFuture started
[01:29:32.300] - Launch lazy future ... done
[01:29:32.300] run() for 'MultisessionFuture' ... done
[01:29:32.301] getGlobalsAndPackages() ...
[01:29:32.301] Searching for globals...
[01:29:32.302] - globals found: [3] '{', 'sample', 'x'
[01:29:32.302] Searching for globals ... DONE
[01:29:32.303] Resolving globals: FALSE
[01:29:32.303] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:32.304] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:32.304] - globals: [1] 'x'
[01:29:32.304] 
[01:29:32.304] getGlobalsAndPackages() ... DONE
[01:29:32.304] run() for 'Future' ...
[01:29:32.305] - state: 'created'
[01:29:32.305] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:32.319] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:32.319] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:32.320]   - Field: 'node'
[01:29:32.320]   - Field: 'label'
[01:29:32.320]   - Field: 'local'
[01:29:32.320]   - Field: 'owner'
[01:29:32.320]   - Field: 'envir'
[01:29:32.321]   - Field: 'workers'
[01:29:32.321]   - Field: 'packages'
[01:29:32.321]   - Field: 'gc'
[01:29:32.321]   - Field: 'conditions'
[01:29:32.321]   - Field: 'persistent'
[01:29:32.321]   - Field: 'expr'
[01:29:32.322]   - Field: 'uuid'
[01:29:32.322]   - Field: 'seed'
[01:29:32.322]   - Field: 'version'
[01:29:32.322]   - Field: 'result'
[01:29:32.322]   - Field: 'asynchronous'
[01:29:32.323]   - Field: 'calls'
[01:29:32.323]   - Field: 'globals'
[01:29:32.323]   - Field: 'stdout'
[01:29:32.323]   - Field: 'earlySignal'
[01:29:32.323]   - Field: 'lazy'
[01:29:32.323]   - Field: 'state'
[01:29:32.324] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:32.324] - Launch lazy future ...
[01:29:32.324] Packages needed by the future expression (n = 0): <none>
[01:29:32.324] Packages needed by future strategies (n = 0): <none>
[01:29:32.325] {
[01:29:32.325]     {
[01:29:32.325]         {
[01:29:32.325]             ...future.startTime <- base::Sys.time()
[01:29:32.325]             {
[01:29:32.325]                 {
[01:29:32.325]                   {
[01:29:32.325]                     {
[01:29:32.325]                       base::local({
[01:29:32.325]                         has_future <- base::requireNamespace("future", 
[01:29:32.325]                           quietly = TRUE)
[01:29:32.325]                         if (has_future) {
[01:29:32.325]                           ns <- base::getNamespace("future")
[01:29:32.325]                           version <- ns[[".package"]][["version"]]
[01:29:32.325]                           if (is.null(version)) 
[01:29:32.325]                             version <- utils::packageVersion("future")
[01:29:32.325]                         }
[01:29:32.325]                         else {
[01:29:32.325]                           version <- NULL
[01:29:32.325]                         }
[01:29:32.325]                         if (!has_future || version < "1.8.0") {
[01:29:32.325]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:32.325]                             "", base::R.version$version.string), 
[01:29:32.325]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:32.325]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:32.325]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:32.325]                               "release", "version")], collapse = " "), 
[01:29:32.325]                             hostname = base::Sys.info()[["nodename"]])
[01:29:32.325]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:32.325]                             info)
[01:29:32.325]                           info <- base::paste(info, collapse = "; ")
[01:29:32.325]                           if (!has_future) {
[01:29:32.325]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:32.325]                               info)
[01:29:32.325]                           }
[01:29:32.325]                           else {
[01:29:32.325]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:32.325]                               info, version)
[01:29:32.325]                           }
[01:29:32.325]                           base::stop(msg)
[01:29:32.325]                         }
[01:29:32.325]                       })
[01:29:32.325]                     }
[01:29:32.325]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:32.325]                     base::options(mc.cores = 1L)
[01:29:32.325]                   }
[01:29:32.325]                   options(future.plan = NULL)
[01:29:32.325]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.325]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:32.325]                 }
[01:29:32.325]                 ...future.workdir <- getwd()
[01:29:32.325]             }
[01:29:32.325]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:32.325]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:32.325]         }
[01:29:32.325]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:32.325]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:32.325]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:32.325]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:32.325]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:32.325]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:32.325]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:32.325]             base::names(...future.oldOptions))
[01:29:32.325]     }
[01:29:32.325]     if (FALSE) {
[01:29:32.325]     }
[01:29:32.325]     else {
[01:29:32.325]         if (TRUE) {
[01:29:32.325]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:32.325]                 open = "w")
[01:29:32.325]         }
[01:29:32.325]         else {
[01:29:32.325]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:32.325]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:32.325]         }
[01:29:32.325]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:32.325]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:32.325]             base::sink(type = "output", split = FALSE)
[01:29:32.325]             base::close(...future.stdout)
[01:29:32.325]         }, add = TRUE)
[01:29:32.325]     }
[01:29:32.325]     ...future.frame <- base::sys.nframe()
[01:29:32.325]     ...future.conditions <- base::list()
[01:29:32.325]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:32.325]     if (FALSE) {
[01:29:32.325]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:32.325]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:32.325]     }
[01:29:32.325]     ...future.result <- base::tryCatch({
[01:29:32.325]         base::withCallingHandlers({
[01:29:32.325]             ...future.value <- base::withVisible(base::local({
[01:29:32.325]                 ...future.makeSendCondition <- base::local({
[01:29:32.325]                   sendCondition <- NULL
[01:29:32.325]                   function(frame = 1L) {
[01:29:32.325]                     if (is.function(sendCondition)) 
[01:29:32.325]                       return(sendCondition)
[01:29:32.325]                     ns <- getNamespace("parallel")
[01:29:32.325]                     if (exists("sendData", mode = "function", 
[01:29:32.325]                       envir = ns)) {
[01:29:32.325]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:32.325]                         envir = ns)
[01:29:32.325]                       envir <- sys.frame(frame)
[01:29:32.325]                       master <- NULL
[01:29:32.325]                       while (!identical(envir, .GlobalEnv) && 
[01:29:32.325]                         !identical(envir, emptyenv())) {
[01:29:32.325]                         if (exists("master", mode = "list", envir = envir, 
[01:29:32.325]                           inherits = FALSE)) {
[01:29:32.325]                           master <- get("master", mode = "list", 
[01:29:32.325]                             envir = envir, inherits = FALSE)
[01:29:32.325]                           if (inherits(master, c("SOCKnode", 
[01:29:32.325]                             "SOCK0node"))) {
[01:29:32.325]                             sendCondition <<- function(cond) {
[01:29:32.325]                               data <- list(type = "VALUE", value = cond, 
[01:29:32.325]                                 success = TRUE)
[01:29:32.325]                               parallel_sendData(master, data)
[01:29:32.325]                             }
[01:29:32.325]                             return(sendCondition)
[01:29:32.325]                           }
[01:29:32.325]                         }
[01:29:32.325]                         frame <- frame + 1L
[01:29:32.325]                         envir <- sys.frame(frame)
[01:29:32.325]                       }
[01:29:32.325]                     }
[01:29:32.325]                     sendCondition <<- function(cond) NULL
[01:29:32.325]                   }
[01:29:32.325]                 })
[01:29:32.325]                 withCallingHandlers({
[01:29:32.325]                   {
[01:29:32.325]                     sample(x, size = 1L)
[01:29:32.325]                   }
[01:29:32.325]                 }, immediateCondition = function(cond) {
[01:29:32.325]                   sendCondition <- ...future.makeSendCondition()
[01:29:32.325]                   sendCondition(cond)
[01:29:32.325]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.325]                   {
[01:29:32.325]                     inherits <- base::inherits
[01:29:32.325]                     invokeRestart <- base::invokeRestart
[01:29:32.325]                     is.null <- base::is.null
[01:29:32.325]                     muffled <- FALSE
[01:29:32.325]                     if (inherits(cond, "message")) {
[01:29:32.325]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:32.325]                       if (muffled) 
[01:29:32.325]                         invokeRestart("muffleMessage")
[01:29:32.325]                     }
[01:29:32.325]                     else if (inherits(cond, "warning")) {
[01:29:32.325]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:32.325]                       if (muffled) 
[01:29:32.325]                         invokeRestart("muffleWarning")
[01:29:32.325]                     }
[01:29:32.325]                     else if (inherits(cond, "condition")) {
[01:29:32.325]                       if (!is.null(pattern)) {
[01:29:32.325]                         computeRestarts <- base::computeRestarts
[01:29:32.325]                         grepl <- base::grepl
[01:29:32.325]                         restarts <- computeRestarts(cond)
[01:29:32.325]                         for (restart in restarts) {
[01:29:32.325]                           name <- restart$name
[01:29:32.325]                           if (is.null(name)) 
[01:29:32.325]                             next
[01:29:32.325]                           if (!grepl(pattern, name)) 
[01:29:32.325]                             next
[01:29:32.325]                           invokeRestart(restart)
[01:29:32.325]                           muffled <- TRUE
[01:29:32.325]                           break
[01:29:32.325]                         }
[01:29:32.325]                       }
[01:29:32.325]                     }
[01:29:32.325]                     invisible(muffled)
[01:29:32.325]                   }
[01:29:32.325]                   muffleCondition(cond)
[01:29:32.325]                 })
[01:29:32.325]             }))
[01:29:32.325]             future::FutureResult(value = ...future.value$value, 
[01:29:32.325]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.325]                   ...future.rng), globalenv = if (FALSE) 
[01:29:32.325]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:32.325]                     ...future.globalenv.names))
[01:29:32.325]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:32.325]         }, condition = base::local({
[01:29:32.325]             c <- base::c
[01:29:32.325]             inherits <- base::inherits
[01:29:32.325]             invokeRestart <- base::invokeRestart
[01:29:32.325]             length <- base::length
[01:29:32.325]             list <- base::list
[01:29:32.325]             seq.int <- base::seq.int
[01:29:32.325]             signalCondition <- base::signalCondition
[01:29:32.325]             sys.calls <- base::sys.calls
[01:29:32.325]             `[[` <- base::`[[`
[01:29:32.325]             `+` <- base::`+`
[01:29:32.325]             `<<-` <- base::`<<-`
[01:29:32.325]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:32.325]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:32.325]                   3L)]
[01:29:32.325]             }
[01:29:32.325]             function(cond) {
[01:29:32.325]                 is_error <- inherits(cond, "error")
[01:29:32.325]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:32.325]                   NULL)
[01:29:32.325]                 if (is_error) {
[01:29:32.325]                   sessionInformation <- function() {
[01:29:32.325]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:32.325]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:32.325]                       search = base::search(), system = base::Sys.info())
[01:29:32.325]                   }
[01:29:32.325]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.325]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:32.325]                     cond$call), session = sessionInformation(), 
[01:29:32.325]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:32.325]                   signalCondition(cond)
[01:29:32.325]                 }
[01:29:32.325]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:32.325]                 "immediateCondition"))) {
[01:29:32.325]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:32.325]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.325]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:32.325]                   if (TRUE && !signal) {
[01:29:32.325]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.325]                     {
[01:29:32.325]                       inherits <- base::inherits
[01:29:32.325]                       invokeRestart <- base::invokeRestart
[01:29:32.325]                       is.null <- base::is.null
[01:29:32.325]                       muffled <- FALSE
[01:29:32.325]                       if (inherits(cond, "message")) {
[01:29:32.325]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.325]                         if (muffled) 
[01:29:32.325]                           invokeRestart("muffleMessage")
[01:29:32.325]                       }
[01:29:32.325]                       else if (inherits(cond, "warning")) {
[01:29:32.325]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.325]                         if (muffled) 
[01:29:32.325]                           invokeRestart("muffleWarning")
[01:29:32.325]                       }
[01:29:32.325]                       else if (inherits(cond, "condition")) {
[01:29:32.325]                         if (!is.null(pattern)) {
[01:29:32.325]                           computeRestarts <- base::computeRestarts
[01:29:32.325]                           grepl <- base::grepl
[01:29:32.325]                           restarts <- computeRestarts(cond)
[01:29:32.325]                           for (restart in restarts) {
[01:29:32.325]                             name <- restart$name
[01:29:32.325]                             if (is.null(name)) 
[01:29:32.325]                               next
[01:29:32.325]                             if (!grepl(pattern, name)) 
[01:29:32.325]                               next
[01:29:32.325]                             invokeRestart(restart)
[01:29:32.325]                             muffled <- TRUE
[01:29:32.325]                             break
[01:29:32.325]                           }
[01:29:32.325]                         }
[01:29:32.325]                       }
[01:29:32.325]                       invisible(muffled)
[01:29:32.325]                     }
[01:29:32.325]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.325]                   }
[01:29:32.325]                 }
[01:29:32.325]                 else {
[01:29:32.325]                   if (TRUE) {
[01:29:32.325]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.325]                     {
[01:29:32.325]                       inherits <- base::inherits
[01:29:32.325]                       invokeRestart <- base::invokeRestart
[01:29:32.325]                       is.null <- base::is.null
[01:29:32.325]                       muffled <- FALSE
[01:29:32.325]                       if (inherits(cond, "message")) {
[01:29:32.325]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.325]                         if (muffled) 
[01:29:32.325]                           invokeRestart("muffleMessage")
[01:29:32.325]                       }
[01:29:32.325]                       else if (inherits(cond, "warning")) {
[01:29:32.325]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.325]                         if (muffled) 
[01:29:32.325]                           invokeRestart("muffleWarning")
[01:29:32.325]                       }
[01:29:32.325]                       else if (inherits(cond, "condition")) {
[01:29:32.325]                         if (!is.null(pattern)) {
[01:29:32.325]                           computeRestarts <- base::computeRestarts
[01:29:32.325]                           grepl <- base::grepl
[01:29:32.325]                           restarts <- computeRestarts(cond)
[01:29:32.325]                           for (restart in restarts) {
[01:29:32.325]                             name <- restart$name
[01:29:32.325]                             if (is.null(name)) 
[01:29:32.325]                               next
[01:29:32.325]                             if (!grepl(pattern, name)) 
[01:29:32.325]                               next
[01:29:32.325]                             invokeRestart(restart)
[01:29:32.325]                             muffled <- TRUE
[01:29:32.325]                             break
[01:29:32.325]                           }
[01:29:32.325]                         }
[01:29:32.325]                       }
[01:29:32.325]                       invisible(muffled)
[01:29:32.325]                     }
[01:29:32.325]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.325]                   }
[01:29:32.325]                 }
[01:29:32.325]             }
[01:29:32.325]         }))
[01:29:32.325]     }, error = function(ex) {
[01:29:32.325]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:32.325]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.325]                 ...future.rng), started = ...future.startTime, 
[01:29:32.325]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:32.325]             version = "1.8"), class = "FutureResult")
[01:29:32.325]     }, finally = {
[01:29:32.325]         if (!identical(...future.workdir, getwd())) 
[01:29:32.325]             setwd(...future.workdir)
[01:29:32.325]         {
[01:29:32.325]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:32.325]                 ...future.oldOptions$nwarnings <- NULL
[01:29:32.325]             }
[01:29:32.325]             base::options(...future.oldOptions)
[01:29:32.325]             if (.Platform$OS.type == "windows") {
[01:29:32.325]                 old_names <- names(...future.oldEnvVars)
[01:29:32.325]                 envs <- base::Sys.getenv()
[01:29:32.325]                 names <- names(envs)
[01:29:32.325]                 common <- intersect(names, old_names)
[01:29:32.325]                 added <- setdiff(names, old_names)
[01:29:32.325]                 removed <- setdiff(old_names, names)
[01:29:32.325]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:32.325]                   envs[common]]
[01:29:32.325]                 NAMES <- toupper(changed)
[01:29:32.325]                 args <- list()
[01:29:32.325]                 for (kk in seq_along(NAMES)) {
[01:29:32.325]                   name <- changed[[kk]]
[01:29:32.325]                   NAME <- NAMES[[kk]]
[01:29:32.325]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.325]                     next
[01:29:32.325]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.325]                 }
[01:29:32.325]                 NAMES <- toupper(added)
[01:29:32.325]                 for (kk in seq_along(NAMES)) {
[01:29:32.325]                   name <- added[[kk]]
[01:29:32.325]                   NAME <- NAMES[[kk]]
[01:29:32.325]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.325]                     next
[01:29:32.325]                   args[[name]] <- ""
[01:29:32.325]                 }
[01:29:32.325]                 NAMES <- toupper(removed)
[01:29:32.325]                 for (kk in seq_along(NAMES)) {
[01:29:32.325]                   name <- removed[[kk]]
[01:29:32.325]                   NAME <- NAMES[[kk]]
[01:29:32.325]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.325]                     next
[01:29:32.325]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.325]                 }
[01:29:32.325]                 if (length(args) > 0) 
[01:29:32.325]                   base::do.call(base::Sys.setenv, args = args)
[01:29:32.325]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:32.325]             }
[01:29:32.325]             else {
[01:29:32.325]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:32.325]             }
[01:29:32.325]             {
[01:29:32.325]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:32.325]                   0L) {
[01:29:32.325]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:32.325]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:32.325]                   base::options(opts)
[01:29:32.325]                 }
[01:29:32.325]                 {
[01:29:32.325]                   {
[01:29:32.325]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:32.325]                     NULL
[01:29:32.325]                   }
[01:29:32.325]                   options(future.plan = NULL)
[01:29:32.325]                   if (is.na(NA_character_)) 
[01:29:32.325]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.325]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:32.325]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:32.325]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:32.325]                     envir = parent.frame()) 
[01:29:32.325]                   {
[01:29:32.325]                     if (is.function(workers)) 
[01:29:32.325]                       workers <- workers()
[01:29:32.325]                     workers <- structure(as.integer(workers), 
[01:29:32.325]                       class = class(workers))
[01:29:32.325]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:32.325]                       workers >= 1)
[01:29:32.325]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:32.325]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:32.325]                     }
[01:29:32.325]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:32.325]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:32.325]                       envir = envir)
[01:29:32.325]                     if (!future$lazy) 
[01:29:32.325]                       future <- run(future)
[01:29:32.325]                     invisible(future)
[01:29:32.325]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:32.325]                 }
[01:29:32.325]             }
[01:29:32.325]         }
[01:29:32.325]     })
[01:29:32.325]     if (TRUE) {
[01:29:32.325]         base::sink(type = "output", split = FALSE)
[01:29:32.325]         if (TRUE) {
[01:29:32.325]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:32.325]         }
[01:29:32.325]         else {
[01:29:32.325]             ...future.result["stdout"] <- base::list(NULL)
[01:29:32.325]         }
[01:29:32.325]         base::close(...future.stdout)
[01:29:32.325]         ...future.stdout <- NULL
[01:29:32.325]     }
[01:29:32.325]     ...future.result$conditions <- ...future.conditions
[01:29:32.325]     ...future.result$finished <- base::Sys.time()
[01:29:32.325]     ...future.result
[01:29:32.325] }
[01:29:32.330] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:32.346] receiveMessageFromWorker() for ClusterFuture ...
[01:29:32.347] - Validating connection of MultisessionFuture
[01:29:32.347] - received message: FutureResult
[01:29:32.347] - Received FutureResult
[01:29:32.348] - Erased future from FutureRegistry
[01:29:32.348] result() for ClusterFuture ...
[01:29:32.348] - result already collected: FutureResult
[01:29:32.348] result() for ClusterFuture ... done
[01:29:32.348] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:32.348] result() for ClusterFuture ...
[01:29:32.349] - result already collected: FutureResult
[01:29:32.349] result() for ClusterFuture ... done
[01:29:32.349] result() for ClusterFuture ...
[01:29:32.349] - result already collected: FutureResult
[01:29:32.349] result() for ClusterFuture ... done
[01:29:32.350] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:32.351] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:32.351] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:32.351] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:32.352] MultisessionFuture started
[01:29:32.352] - Launch lazy future ... done
[01:29:32.352] run() for 'MultisessionFuture' ... done
[01:29:32.353] getGlobalsAndPackages() ...
[01:29:32.353] Searching for globals...
[01:29:32.355] - globals found: [3] '{', 'sample', 'x'
[01:29:32.355] Searching for globals ... DONE
[01:29:32.355] Resolving globals: FALSE
[01:29:32.355] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:32.356] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:32.356] - globals: [1] 'x'
[01:29:32.356] 
[01:29:32.357] getGlobalsAndPackages() ... DONE
[01:29:32.357] run() for 'Future' ...
[01:29:32.357] - state: 'created'
[01:29:32.357] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:32.372] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:32.373] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:32.373]   - Field: 'node'
[01:29:32.373]   - Field: 'label'
[01:29:32.374]   - Field: 'local'
[01:29:32.374]   - Field: 'owner'
[01:29:32.374]   - Field: 'envir'
[01:29:32.374]   - Field: 'workers'
[01:29:32.375]   - Field: 'packages'
[01:29:32.375]   - Field: 'gc'
[01:29:32.375]   - Field: 'conditions'
[01:29:32.375]   - Field: 'persistent'
[01:29:32.375]   - Field: 'expr'
[01:29:32.376]   - Field: 'uuid'
[01:29:32.376]   - Field: 'seed'
[01:29:32.376]   - Field: 'version'
[01:29:32.376]   - Field: 'result'
[01:29:32.376]   - Field: 'asynchronous'
[01:29:32.377]   - Field: 'calls'
[01:29:32.377]   - Field: 'globals'
[01:29:32.377]   - Field: 'stdout'
[01:29:32.377]   - Field: 'earlySignal'
[01:29:32.378]   - Field: 'lazy'
[01:29:32.378]   - Field: 'state'
[01:29:32.378] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:32.378] - Launch lazy future ...
[01:29:32.379] Packages needed by the future expression (n = 0): <none>
[01:29:32.379] Packages needed by future strategies (n = 0): <none>
[01:29:32.379] {
[01:29:32.379]     {
[01:29:32.379]         {
[01:29:32.379]             ...future.startTime <- base::Sys.time()
[01:29:32.379]             {
[01:29:32.379]                 {
[01:29:32.379]                   {
[01:29:32.379]                     {
[01:29:32.379]                       base::local({
[01:29:32.379]                         has_future <- base::requireNamespace("future", 
[01:29:32.379]                           quietly = TRUE)
[01:29:32.379]                         if (has_future) {
[01:29:32.379]                           ns <- base::getNamespace("future")
[01:29:32.379]                           version <- ns[[".package"]][["version"]]
[01:29:32.379]                           if (is.null(version)) 
[01:29:32.379]                             version <- utils::packageVersion("future")
[01:29:32.379]                         }
[01:29:32.379]                         else {
[01:29:32.379]                           version <- NULL
[01:29:32.379]                         }
[01:29:32.379]                         if (!has_future || version < "1.8.0") {
[01:29:32.379]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:32.379]                             "", base::R.version$version.string), 
[01:29:32.379]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:32.379]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:32.379]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:32.379]                               "release", "version")], collapse = " "), 
[01:29:32.379]                             hostname = base::Sys.info()[["nodename"]])
[01:29:32.379]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:32.379]                             info)
[01:29:32.379]                           info <- base::paste(info, collapse = "; ")
[01:29:32.379]                           if (!has_future) {
[01:29:32.379]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:32.379]                               info)
[01:29:32.379]                           }
[01:29:32.379]                           else {
[01:29:32.379]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:32.379]                               info, version)
[01:29:32.379]                           }
[01:29:32.379]                           base::stop(msg)
[01:29:32.379]                         }
[01:29:32.379]                       })
[01:29:32.379]                     }
[01:29:32.379]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:32.379]                     base::options(mc.cores = 1L)
[01:29:32.379]                   }
[01:29:32.379]                   options(future.plan = NULL)
[01:29:32.379]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.379]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:32.379]                 }
[01:29:32.379]                 ...future.workdir <- getwd()
[01:29:32.379]             }
[01:29:32.379]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:32.379]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:32.379]         }
[01:29:32.379]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:32.379]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:32.379]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:32.379]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:32.379]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[01:29:32.379]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:32.379]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:32.379]             base::names(...future.oldOptions))
[01:29:32.379]     }
[01:29:32.379]     if (FALSE) {
[01:29:32.379]     }
[01:29:32.379]     else {
[01:29:32.379]         if (TRUE) {
[01:29:32.379]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:32.379]                 open = "w")
[01:29:32.379]         }
[01:29:32.379]         else {
[01:29:32.379]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:32.379]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:32.379]         }
[01:29:32.379]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:32.379]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:32.379]             base::sink(type = "output", split = FALSE)
[01:29:32.379]             base::close(...future.stdout)
[01:29:32.379]         }, add = TRUE)
[01:29:32.379]     }
[01:29:32.379]     ...future.frame <- base::sys.nframe()
[01:29:32.379]     ...future.conditions <- base::list()
[01:29:32.379]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:32.379]     if (FALSE) {
[01:29:32.379]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:32.379]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:32.379]     }
[01:29:32.379]     ...future.result <- base::tryCatch({
[01:29:32.379]         base::withCallingHandlers({
[01:29:32.379]             ...future.value <- base::withVisible(base::local({
[01:29:32.379]                 ...future.makeSendCondition <- base::local({
[01:29:32.379]                   sendCondition <- NULL
[01:29:32.379]                   function(frame = 1L) {
[01:29:32.379]                     if (is.function(sendCondition)) 
[01:29:32.379]                       return(sendCondition)
[01:29:32.379]                     ns <- getNamespace("parallel")
[01:29:32.379]                     if (exists("sendData", mode = "function", 
[01:29:32.379]                       envir = ns)) {
[01:29:32.379]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:32.379]                         envir = ns)
[01:29:32.379]                       envir <- sys.frame(frame)
[01:29:32.379]                       master <- NULL
[01:29:32.379]                       while (!identical(envir, .GlobalEnv) && 
[01:29:32.379]                         !identical(envir, emptyenv())) {
[01:29:32.379]                         if (exists("master", mode = "list", envir = envir, 
[01:29:32.379]                           inherits = FALSE)) {
[01:29:32.379]                           master <- get("master", mode = "list", 
[01:29:32.379]                             envir = envir, inherits = FALSE)
[01:29:32.379]                           if (inherits(master, c("SOCKnode", 
[01:29:32.379]                             "SOCK0node"))) {
[01:29:32.379]                             sendCondition <<- function(cond) {
[01:29:32.379]                               data <- list(type = "VALUE", value = cond, 
[01:29:32.379]                                 success = TRUE)
[01:29:32.379]                               parallel_sendData(master, data)
[01:29:32.379]                             }
[01:29:32.379]                             return(sendCondition)
[01:29:32.379]                           }
[01:29:32.379]                         }
[01:29:32.379]                         frame <- frame + 1L
[01:29:32.379]                         envir <- sys.frame(frame)
[01:29:32.379]                       }
[01:29:32.379]                     }
[01:29:32.379]                     sendCondition <<- function(cond) NULL
[01:29:32.379]                   }
[01:29:32.379]                 })
[01:29:32.379]                 withCallingHandlers({
[01:29:32.379]                   {
[01:29:32.379]                     sample(x, size = 1L)
[01:29:32.379]                   }
[01:29:32.379]                 }, immediateCondition = function(cond) {
[01:29:32.379]                   sendCondition <- ...future.makeSendCondition()
[01:29:32.379]                   sendCondition(cond)
[01:29:32.379]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.379]                   {
[01:29:32.379]                     inherits <- base::inherits
[01:29:32.379]                     invokeRestart <- base::invokeRestart
[01:29:32.379]                     is.null <- base::is.null
[01:29:32.379]                     muffled <- FALSE
[01:29:32.379]                     if (inherits(cond, "message")) {
[01:29:32.379]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:32.379]                       if (muffled) 
[01:29:32.379]                         invokeRestart("muffleMessage")
[01:29:32.379]                     }
[01:29:32.379]                     else if (inherits(cond, "warning")) {
[01:29:32.379]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:32.379]                       if (muffled) 
[01:29:32.379]                         invokeRestart("muffleWarning")
[01:29:32.379]                     }
[01:29:32.379]                     else if (inherits(cond, "condition")) {
[01:29:32.379]                       if (!is.null(pattern)) {
[01:29:32.379]                         computeRestarts <- base::computeRestarts
[01:29:32.379]                         grepl <- base::grepl
[01:29:32.379]                         restarts <- computeRestarts(cond)
[01:29:32.379]                         for (restart in restarts) {
[01:29:32.379]                           name <- restart$name
[01:29:32.379]                           if (is.null(name)) 
[01:29:32.379]                             next
[01:29:32.379]                           if (!grepl(pattern, name)) 
[01:29:32.379]                             next
[01:29:32.379]                           invokeRestart(restart)
[01:29:32.379]                           muffled <- TRUE
[01:29:32.379]                           break
[01:29:32.379]                         }
[01:29:32.379]                       }
[01:29:32.379]                     }
[01:29:32.379]                     invisible(muffled)
[01:29:32.379]                   }
[01:29:32.379]                   muffleCondition(cond)
[01:29:32.379]                 })
[01:29:32.379]             }))
[01:29:32.379]             future::FutureResult(value = ...future.value$value, 
[01:29:32.379]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.379]                   ...future.rng), globalenv = if (FALSE) 
[01:29:32.379]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:32.379]                     ...future.globalenv.names))
[01:29:32.379]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:32.379]         }, condition = base::local({
[01:29:32.379]             c <- base::c
[01:29:32.379]             inherits <- base::inherits
[01:29:32.379]             invokeRestart <- base::invokeRestart
[01:29:32.379]             length <- base::length
[01:29:32.379]             list <- base::list
[01:29:32.379]             seq.int <- base::seq.int
[01:29:32.379]             signalCondition <- base::signalCondition
[01:29:32.379]             sys.calls <- base::sys.calls
[01:29:32.379]             `[[` <- base::`[[`
[01:29:32.379]             `+` <- base::`+`
[01:29:32.379]             `<<-` <- base::`<<-`
[01:29:32.379]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:32.379]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:32.379]                   3L)]
[01:29:32.379]             }
[01:29:32.379]             function(cond) {
[01:29:32.379]                 is_error <- inherits(cond, "error")
[01:29:32.379]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:32.379]                   NULL)
[01:29:32.379]                 if (is_error) {
[01:29:32.379]                   sessionInformation <- function() {
[01:29:32.379]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:32.379]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:32.379]                       search = base::search(), system = base::Sys.info())
[01:29:32.379]                   }
[01:29:32.379]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.379]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:32.379]                     cond$call), session = sessionInformation(), 
[01:29:32.379]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:32.379]                   signalCondition(cond)
[01:29:32.379]                 }
[01:29:32.379]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:32.379]                 "immediateCondition"))) {
[01:29:32.379]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:32.379]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.379]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:32.379]                   if (TRUE && !signal) {
[01:29:32.379]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.379]                     {
[01:29:32.379]                       inherits <- base::inherits
[01:29:32.379]                       invokeRestart <- base::invokeRestart
[01:29:32.379]                       is.null <- base::is.null
[01:29:32.379]                       muffled <- FALSE
[01:29:32.379]                       if (inherits(cond, "message")) {
[01:29:32.379]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.379]                         if (muffled) 
[01:29:32.379]                           invokeRestart("muffleMessage")
[01:29:32.379]                       }
[01:29:32.379]                       else if (inherits(cond, "warning")) {
[01:29:32.379]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.379]                         if (muffled) 
[01:29:32.379]                           invokeRestart("muffleWarning")
[01:29:32.379]                       }
[01:29:32.379]                       else if (inherits(cond, "condition")) {
[01:29:32.379]                         if (!is.null(pattern)) {
[01:29:32.379]                           computeRestarts <- base::computeRestarts
[01:29:32.379]                           grepl <- base::grepl
[01:29:32.379]                           restarts <- computeRestarts(cond)
[01:29:32.379]                           for (restart in restarts) {
[01:29:32.379]                             name <- restart$name
[01:29:32.379]                             if (is.null(name)) 
[01:29:32.379]                               next
[01:29:32.379]                             if (!grepl(pattern, name)) 
[01:29:32.379]                               next
[01:29:32.379]                             invokeRestart(restart)
[01:29:32.379]                             muffled <- TRUE
[01:29:32.379]                             break
[01:29:32.379]                           }
[01:29:32.379]                         }
[01:29:32.379]                       }
[01:29:32.379]                       invisible(muffled)
[01:29:32.379]                     }
[01:29:32.379]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.379]                   }
[01:29:32.379]                 }
[01:29:32.379]                 else {
[01:29:32.379]                   if (TRUE) {
[01:29:32.379]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.379]                     {
[01:29:32.379]                       inherits <- base::inherits
[01:29:32.379]                       invokeRestart <- base::invokeRestart
[01:29:32.379]                       is.null <- base::is.null
[01:29:32.379]                       muffled <- FALSE
[01:29:32.379]                       if (inherits(cond, "message")) {
[01:29:32.379]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.379]                         if (muffled) 
[01:29:32.379]                           invokeRestart("muffleMessage")
[01:29:32.379]                       }
[01:29:32.379]                       else if (inherits(cond, "warning")) {
[01:29:32.379]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.379]                         if (muffled) 
[01:29:32.379]                           invokeRestart("muffleWarning")
[01:29:32.379]                       }
[01:29:32.379]                       else if (inherits(cond, "condition")) {
[01:29:32.379]                         if (!is.null(pattern)) {
[01:29:32.379]                           computeRestarts <- base::computeRestarts
[01:29:32.379]                           grepl <- base::grepl
[01:29:32.379]                           restarts <- computeRestarts(cond)
[01:29:32.379]                           for (restart in restarts) {
[01:29:32.379]                             name <- restart$name
[01:29:32.379]                             if (is.null(name)) 
[01:29:32.379]                               next
[01:29:32.379]                             if (!grepl(pattern, name)) 
[01:29:32.379]                               next
[01:29:32.379]                             invokeRestart(restart)
[01:29:32.379]                             muffled <- TRUE
[01:29:32.379]                             break
[01:29:32.379]                           }
[01:29:32.379]                         }
[01:29:32.379]                       }
[01:29:32.379]                       invisible(muffled)
[01:29:32.379]                     }
[01:29:32.379]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.379]                   }
[01:29:32.379]                 }
[01:29:32.379]             }
[01:29:32.379]         }))
[01:29:32.379]     }, error = function(ex) {
[01:29:32.379]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:32.379]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.379]                 ...future.rng), started = ...future.startTime, 
[01:29:32.379]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:32.379]             version = "1.8"), class = "FutureResult")
[01:29:32.379]     }, finally = {
[01:29:32.379]         if (!identical(...future.workdir, getwd())) 
[01:29:32.379]             setwd(...future.workdir)
[01:29:32.379]         {
[01:29:32.379]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:32.379]                 ...future.oldOptions$nwarnings <- NULL
[01:29:32.379]             }
[01:29:32.379]             base::options(...future.oldOptions)
[01:29:32.379]             if (.Platform$OS.type == "windows") {
[01:29:32.379]                 old_names <- names(...future.oldEnvVars)
[01:29:32.379]                 envs <- base::Sys.getenv()
[01:29:32.379]                 names <- names(envs)
[01:29:32.379]                 common <- intersect(names, old_names)
[01:29:32.379]                 added <- setdiff(names, old_names)
[01:29:32.379]                 removed <- setdiff(old_names, names)
[01:29:32.379]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:32.379]                   envs[common]]
[01:29:32.379]                 NAMES <- toupper(changed)
[01:29:32.379]                 args <- list()
[01:29:32.379]                 for (kk in seq_along(NAMES)) {
[01:29:32.379]                   name <- changed[[kk]]
[01:29:32.379]                   NAME <- NAMES[[kk]]
[01:29:32.379]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.379]                     next
[01:29:32.379]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.379]                 }
[01:29:32.379]                 NAMES <- toupper(added)
[01:29:32.379]                 for (kk in seq_along(NAMES)) {
[01:29:32.379]                   name <- added[[kk]]
[01:29:32.379]                   NAME <- NAMES[[kk]]
[01:29:32.379]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.379]                     next
[01:29:32.379]                   args[[name]] <- ""
[01:29:32.379]                 }
[01:29:32.379]                 NAMES <- toupper(removed)
[01:29:32.379]                 for (kk in seq_along(NAMES)) {
[01:29:32.379]                   name <- removed[[kk]]
[01:29:32.379]                   NAME <- NAMES[[kk]]
[01:29:32.379]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.379]                     next
[01:29:32.379]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.379]                 }
[01:29:32.379]                 if (length(args) > 0) 
[01:29:32.379]                   base::do.call(base::Sys.setenv, args = args)
[01:29:32.379]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:32.379]             }
[01:29:32.379]             else {
[01:29:32.379]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:32.379]             }
[01:29:32.379]             {
[01:29:32.379]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:32.379]                   0L) {
[01:29:32.379]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:32.379]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:32.379]                   base::options(opts)
[01:29:32.379]                 }
[01:29:32.379]                 {
[01:29:32.379]                   {
[01:29:32.379]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:32.379]                     NULL
[01:29:32.379]                   }
[01:29:32.379]                   options(future.plan = NULL)
[01:29:32.379]                   if (is.na(NA_character_)) 
[01:29:32.379]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.379]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:32.379]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:32.379]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:32.379]                     envir = parent.frame()) 
[01:29:32.379]                   {
[01:29:32.379]                     if (is.function(workers)) 
[01:29:32.379]                       workers <- workers()
[01:29:32.379]                     workers <- structure(as.integer(workers), 
[01:29:32.379]                       class = class(workers))
[01:29:32.379]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:32.379]                       workers >= 1)
[01:29:32.379]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:32.379]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:32.379]                     }
[01:29:32.379]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:32.379]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:32.379]                       envir = envir)
[01:29:32.379]                     if (!future$lazy) 
[01:29:32.379]                       future <- run(future)
[01:29:32.379]                     invisible(future)
[01:29:32.379]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:32.379]                 }
[01:29:32.379]             }
[01:29:32.379]         }
[01:29:32.379]     })
[01:29:32.379]     if (TRUE) {
[01:29:32.379]         base::sink(type = "output", split = FALSE)
[01:29:32.379]         if (TRUE) {
[01:29:32.379]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:32.379]         }
[01:29:32.379]         else {
[01:29:32.379]             ...future.result["stdout"] <- base::list(NULL)
[01:29:32.379]         }
[01:29:32.379]         base::close(...future.stdout)
[01:29:32.379]         ...future.stdout <- NULL
[01:29:32.379]     }
[01:29:32.379]     ...future.result$conditions <- ...future.conditions
[01:29:32.379]     ...future.result$finished <- base::Sys.time()
[01:29:32.379]     ...future.result
[01:29:32.379] }
[01:29:32.384] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:32.409] receiveMessageFromWorker() for ClusterFuture ...
[01:29:32.409] - Validating connection of MultisessionFuture
[01:29:32.409] - received message: FutureResult
[01:29:32.410] - Received FutureResult
[01:29:32.410] - Erased future from FutureRegistry
[01:29:32.410] result() for ClusterFuture ...
[01:29:32.410] - result already collected: FutureResult
[01:29:32.410] result() for ClusterFuture ... done
[01:29:32.411] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:32.411] result() for ClusterFuture ...
[01:29:32.411] - result already collected: FutureResult
[01:29:32.411] result() for ClusterFuture ... done
[01:29:32.411] result() for ClusterFuture ...
[01:29:32.412] - result already collected: FutureResult
[01:29:32.412] result() for ClusterFuture ... done
[01:29:32.412] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:32.413] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:32.413] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:32.413] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:32.414] MultisessionFuture started
[01:29:32.414] - Launch lazy future ... done
[01:29:32.414] run() for 'MultisessionFuture' ... done
[01:29:32.415] result() for ClusterFuture ...
[01:29:32.415] - result already collected: FutureResult
[01:29:32.415] result() for ClusterFuture ... done
[01:29:32.415] result() for ClusterFuture ...
[01:29:32.415] - result already collected: FutureResult
[01:29:32.415] result() for ClusterFuture ... done
[01:29:32.416] result() for ClusterFuture ...
[01:29:32.416] - result already collected: FutureResult
[01:29:32.416] result() for ClusterFuture ... done
[01:29:32.416] result() for ClusterFuture ...
[01:29:32.416] - result already collected: FutureResult
[01:29:32.417] result() for ClusterFuture ... done
[01:29:32.417] result() for ClusterFuture ...
[01:29:32.417] receiveMessageFromWorker() for ClusterFuture ...
[01:29:32.417] - Validating connection of MultisessionFuture
[01:29:32.417] - received message: FutureResult
[01:29:32.418] - Received FutureResult
[01:29:32.418] - Erased future from FutureRegistry
[01:29:32.418] result() for ClusterFuture ...
[01:29:32.418] - result already collected: FutureResult
[01:29:32.418] result() for ClusterFuture ... done
[01:29:32.418] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:32.419] result() for ClusterFuture ... done
[01:29:32.419] result() for ClusterFuture ...
[01:29:32.419] - result already collected: FutureResult
[01:29:32.419] result() for ClusterFuture ... done
[01:29:32.419] result() for ClusterFuture ...
[01:29:32.419] receiveMessageFromWorker() for ClusterFuture ...
[01:29:32.420] - Validating connection of MultisessionFuture
[01:29:32.437] - received message: FutureResult
[01:29:32.437] - Received FutureResult
[01:29:32.437] - Erased future from FutureRegistry
[01:29:32.438] result() for ClusterFuture ...
[01:29:32.438] - result already collected: FutureResult
[01:29:32.438] result() for ClusterFuture ... done
[01:29:32.438] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:32.438] result() for ClusterFuture ... done
[01:29:32.438] result() for ClusterFuture ...
[01:29:32.439] - result already collected: FutureResult
[01:29:32.439] result() for ClusterFuture ... done
[[1]]
[1] 1

[[2]]
[1] 0

[[3]]
[1] 3

[[4]]
[1] 3

[01:29:32.440] getGlobalsAndPackages() ...
[01:29:32.440] Searching for globals...
[01:29:32.441] - globals found: [3] '{', 'sample', 'x'
[01:29:32.441] Searching for globals ... DONE
[01:29:32.442] Resolving globals: FALSE
[01:29:32.442] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:32.443] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:32.443] - globals: [1] 'x'
[01:29:32.443] 
[01:29:32.443] getGlobalsAndPackages() ... DONE
[01:29:32.444] run() for 'Future' ...
[01:29:32.444] - state: 'created'
[01:29:32.444] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:32.460] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:32.461] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:32.461]   - Field: 'node'
[01:29:32.461]   - Field: 'label'
[01:29:32.462]   - Field: 'local'
[01:29:32.462]   - Field: 'owner'
[01:29:32.462]   - Field: 'envir'
[01:29:32.462]   - Field: 'workers'
[01:29:32.463]   - Field: 'packages'
[01:29:32.463]   - Field: 'gc'
[01:29:32.463]   - Field: 'conditions'
[01:29:32.463]   - Field: 'persistent'
[01:29:32.464]   - Field: 'expr'
[01:29:32.464]   - Field: 'uuid'
[01:29:32.464]   - Field: 'seed'
[01:29:32.464]   - Field: 'version'
[01:29:32.465]   - Field: 'result'
[01:29:32.465]   - Field: 'asynchronous'
[01:29:32.465]   - Field: 'calls'
[01:29:32.465]   - Field: 'globals'
[01:29:32.466]   - Field: 'stdout'
[01:29:32.466]   - Field: 'earlySignal'
[01:29:32.466]   - Field: 'lazy'
[01:29:32.466]   - Field: 'state'
[01:29:32.467] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:32.467] - Launch lazy future ...
[01:29:32.468] Packages needed by the future expression (n = 0): <none>
[01:29:32.468] Packages needed by future strategies (n = 0): <none>
[01:29:32.469] {
[01:29:32.469]     {
[01:29:32.469]         {
[01:29:32.469]             ...future.startTime <- base::Sys.time()
[01:29:32.469]             {
[01:29:32.469]                 {
[01:29:32.469]                   {
[01:29:32.469]                     {
[01:29:32.469]                       base::local({
[01:29:32.469]                         has_future <- base::requireNamespace("future", 
[01:29:32.469]                           quietly = TRUE)
[01:29:32.469]                         if (has_future) {
[01:29:32.469]                           ns <- base::getNamespace("future")
[01:29:32.469]                           version <- ns[[".package"]][["version"]]
[01:29:32.469]                           if (is.null(version)) 
[01:29:32.469]                             version <- utils::packageVersion("future")
[01:29:32.469]                         }
[01:29:32.469]                         else {
[01:29:32.469]                           version <- NULL
[01:29:32.469]                         }
[01:29:32.469]                         if (!has_future || version < "1.8.0") {
[01:29:32.469]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:32.469]                             "", base::R.version$version.string), 
[01:29:32.469]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:32.469]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:32.469]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:32.469]                               "release", "version")], collapse = " "), 
[01:29:32.469]                             hostname = base::Sys.info()[["nodename"]])
[01:29:32.469]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:32.469]                             info)
[01:29:32.469]                           info <- base::paste(info, collapse = "; ")
[01:29:32.469]                           if (!has_future) {
[01:29:32.469]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:32.469]                               info)
[01:29:32.469]                           }
[01:29:32.469]                           else {
[01:29:32.469]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:32.469]                               info, version)
[01:29:32.469]                           }
[01:29:32.469]                           base::stop(msg)
[01:29:32.469]                         }
[01:29:32.469]                       })
[01:29:32.469]                     }
[01:29:32.469]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:32.469]                     base::options(mc.cores = 1L)
[01:29:32.469]                   }
[01:29:32.469]                   options(future.plan = NULL)
[01:29:32.469]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.469]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:32.469]                 }
[01:29:32.469]                 ...future.workdir <- getwd()
[01:29:32.469]             }
[01:29:32.469]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:32.469]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:32.469]         }
[01:29:32.469]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:32.469]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:32.469]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:32.469]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:32.469]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:32.469]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:32.469]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:32.469]             base::names(...future.oldOptions))
[01:29:32.469]     }
[01:29:32.469]     if (FALSE) {
[01:29:32.469]     }
[01:29:32.469]     else {
[01:29:32.469]         if (TRUE) {
[01:29:32.469]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:32.469]                 open = "w")
[01:29:32.469]         }
[01:29:32.469]         else {
[01:29:32.469]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:32.469]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:32.469]         }
[01:29:32.469]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:32.469]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:32.469]             base::sink(type = "output", split = FALSE)
[01:29:32.469]             base::close(...future.stdout)
[01:29:32.469]         }, add = TRUE)
[01:29:32.469]     }
[01:29:32.469]     ...future.frame <- base::sys.nframe()
[01:29:32.469]     ...future.conditions <- base::list()
[01:29:32.469]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:32.469]     if (FALSE) {
[01:29:32.469]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:32.469]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:32.469]     }
[01:29:32.469]     ...future.result <- base::tryCatch({
[01:29:32.469]         base::withCallingHandlers({
[01:29:32.469]             ...future.value <- base::withVisible(base::local({
[01:29:32.469]                 ...future.makeSendCondition <- base::local({
[01:29:32.469]                   sendCondition <- NULL
[01:29:32.469]                   function(frame = 1L) {
[01:29:32.469]                     if (is.function(sendCondition)) 
[01:29:32.469]                       return(sendCondition)
[01:29:32.469]                     ns <- getNamespace("parallel")
[01:29:32.469]                     if (exists("sendData", mode = "function", 
[01:29:32.469]                       envir = ns)) {
[01:29:32.469]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:32.469]                         envir = ns)
[01:29:32.469]                       envir <- sys.frame(frame)
[01:29:32.469]                       master <- NULL
[01:29:32.469]                       while (!identical(envir, .GlobalEnv) && 
[01:29:32.469]                         !identical(envir, emptyenv())) {
[01:29:32.469]                         if (exists("master", mode = "list", envir = envir, 
[01:29:32.469]                           inherits = FALSE)) {
[01:29:32.469]                           master <- get("master", mode = "list", 
[01:29:32.469]                             envir = envir, inherits = FALSE)
[01:29:32.469]                           if (inherits(master, c("SOCKnode", 
[01:29:32.469]                             "SOCK0node"))) {
[01:29:32.469]                             sendCondition <<- function(cond) {
[01:29:32.469]                               data <- list(type = "VALUE", value = cond, 
[01:29:32.469]                                 success = TRUE)
[01:29:32.469]                               parallel_sendData(master, data)
[01:29:32.469]                             }
[01:29:32.469]                             return(sendCondition)
[01:29:32.469]                           }
[01:29:32.469]                         }
[01:29:32.469]                         frame <- frame + 1L
[01:29:32.469]                         envir <- sys.frame(frame)
[01:29:32.469]                       }
[01:29:32.469]                     }
[01:29:32.469]                     sendCondition <<- function(cond) NULL
[01:29:32.469]                   }
[01:29:32.469]                 })
[01:29:32.469]                 withCallingHandlers({
[01:29:32.469]                   {
[01:29:32.469]                     sample(x, size = 1L)
[01:29:32.469]                   }
[01:29:32.469]                 }, immediateCondition = function(cond) {
[01:29:32.469]                   sendCondition <- ...future.makeSendCondition()
[01:29:32.469]                   sendCondition(cond)
[01:29:32.469]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.469]                   {
[01:29:32.469]                     inherits <- base::inherits
[01:29:32.469]                     invokeRestart <- base::invokeRestart
[01:29:32.469]                     is.null <- base::is.null
[01:29:32.469]                     muffled <- FALSE
[01:29:32.469]                     if (inherits(cond, "message")) {
[01:29:32.469]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:32.469]                       if (muffled) 
[01:29:32.469]                         invokeRestart("muffleMessage")
[01:29:32.469]                     }
[01:29:32.469]                     else if (inherits(cond, "warning")) {
[01:29:32.469]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:32.469]                       if (muffled) 
[01:29:32.469]                         invokeRestart("muffleWarning")
[01:29:32.469]                     }
[01:29:32.469]                     else if (inherits(cond, "condition")) {
[01:29:32.469]                       if (!is.null(pattern)) {
[01:29:32.469]                         computeRestarts <- base::computeRestarts
[01:29:32.469]                         grepl <- base::grepl
[01:29:32.469]                         restarts <- computeRestarts(cond)
[01:29:32.469]                         for (restart in restarts) {
[01:29:32.469]                           name <- restart$name
[01:29:32.469]                           if (is.null(name)) 
[01:29:32.469]                             next
[01:29:32.469]                           if (!grepl(pattern, name)) 
[01:29:32.469]                             next
[01:29:32.469]                           invokeRestart(restart)
[01:29:32.469]                           muffled <- TRUE
[01:29:32.469]                           break
[01:29:32.469]                         }
[01:29:32.469]                       }
[01:29:32.469]                     }
[01:29:32.469]                     invisible(muffled)
[01:29:32.469]                   }
[01:29:32.469]                   muffleCondition(cond)
[01:29:32.469]                 })
[01:29:32.469]             }))
[01:29:32.469]             future::FutureResult(value = ...future.value$value, 
[01:29:32.469]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.469]                   ...future.rng), globalenv = if (FALSE) 
[01:29:32.469]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:32.469]                     ...future.globalenv.names))
[01:29:32.469]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:32.469]         }, condition = base::local({
[01:29:32.469]             c <- base::c
[01:29:32.469]             inherits <- base::inherits
[01:29:32.469]             invokeRestart <- base::invokeRestart
[01:29:32.469]             length <- base::length
[01:29:32.469]             list <- base::list
[01:29:32.469]             seq.int <- base::seq.int
[01:29:32.469]             signalCondition <- base::signalCondition
[01:29:32.469]             sys.calls <- base::sys.calls
[01:29:32.469]             `[[` <- base::`[[`
[01:29:32.469]             `+` <- base::`+`
[01:29:32.469]             `<<-` <- base::`<<-`
[01:29:32.469]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:32.469]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:32.469]                   3L)]
[01:29:32.469]             }
[01:29:32.469]             function(cond) {
[01:29:32.469]                 is_error <- inherits(cond, "error")
[01:29:32.469]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:32.469]                   NULL)
[01:29:32.469]                 if (is_error) {
[01:29:32.469]                   sessionInformation <- function() {
[01:29:32.469]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:32.469]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:32.469]                       search = base::search(), system = base::Sys.info())
[01:29:32.469]                   }
[01:29:32.469]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.469]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:32.469]                     cond$call), session = sessionInformation(), 
[01:29:32.469]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:32.469]                   signalCondition(cond)
[01:29:32.469]                 }
[01:29:32.469]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:32.469]                 "immediateCondition"))) {
[01:29:32.469]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:32.469]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.469]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:32.469]                   if (TRUE && !signal) {
[01:29:32.469]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.469]                     {
[01:29:32.469]                       inherits <- base::inherits
[01:29:32.469]                       invokeRestart <- base::invokeRestart
[01:29:32.469]                       is.null <- base::is.null
[01:29:32.469]                       muffled <- FALSE
[01:29:32.469]                       if (inherits(cond, "message")) {
[01:29:32.469]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.469]                         if (muffled) 
[01:29:32.469]                           invokeRestart("muffleMessage")
[01:29:32.469]                       }
[01:29:32.469]                       else if (inherits(cond, "warning")) {
[01:29:32.469]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.469]                         if (muffled) 
[01:29:32.469]                           invokeRestart("muffleWarning")
[01:29:32.469]                       }
[01:29:32.469]                       else if (inherits(cond, "condition")) {
[01:29:32.469]                         if (!is.null(pattern)) {
[01:29:32.469]                           computeRestarts <- base::computeRestarts
[01:29:32.469]                           grepl <- base::grepl
[01:29:32.469]                           restarts <- computeRestarts(cond)
[01:29:32.469]                           for (restart in restarts) {
[01:29:32.469]                             name <- restart$name
[01:29:32.469]                             if (is.null(name)) 
[01:29:32.469]                               next
[01:29:32.469]                             if (!grepl(pattern, name)) 
[01:29:32.469]                               next
[01:29:32.469]                             invokeRestart(restart)
[01:29:32.469]                             muffled <- TRUE
[01:29:32.469]                             break
[01:29:32.469]                           }
[01:29:32.469]                         }
[01:29:32.469]                       }
[01:29:32.469]                       invisible(muffled)
[01:29:32.469]                     }
[01:29:32.469]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.469]                   }
[01:29:32.469]                 }
[01:29:32.469]                 else {
[01:29:32.469]                   if (TRUE) {
[01:29:32.469]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.469]                     {
[01:29:32.469]                       inherits <- base::inherits
[01:29:32.469]                       invokeRestart <- base::invokeRestart
[01:29:32.469]                       is.null <- base::is.null
[01:29:32.469]                       muffled <- FALSE
[01:29:32.469]                       if (inherits(cond, "message")) {
[01:29:32.469]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.469]                         if (muffled) 
[01:29:32.469]                           invokeRestart("muffleMessage")
[01:29:32.469]                       }
[01:29:32.469]                       else if (inherits(cond, "warning")) {
[01:29:32.469]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.469]                         if (muffled) 
[01:29:32.469]                           invokeRestart("muffleWarning")
[01:29:32.469]                       }
[01:29:32.469]                       else if (inherits(cond, "condition")) {
[01:29:32.469]                         if (!is.null(pattern)) {
[01:29:32.469]                           computeRestarts <- base::computeRestarts
[01:29:32.469]                           grepl <- base::grepl
[01:29:32.469]                           restarts <- computeRestarts(cond)
[01:29:32.469]                           for (restart in restarts) {
[01:29:32.469]                             name <- restart$name
[01:29:32.469]                             if (is.null(name)) 
[01:29:32.469]                               next
[01:29:32.469]                             if (!grepl(pattern, name)) 
[01:29:32.469]                               next
[01:29:32.469]                             invokeRestart(restart)
[01:29:32.469]                             muffled <- TRUE
[01:29:32.469]                             break
[01:29:32.469]                           }
[01:29:32.469]                         }
[01:29:32.469]                       }
[01:29:32.469]                       invisible(muffled)
[01:29:32.469]                     }
[01:29:32.469]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.469]                   }
[01:29:32.469]                 }
[01:29:32.469]             }
[01:29:32.469]         }))
[01:29:32.469]     }, error = function(ex) {
[01:29:32.469]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:32.469]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.469]                 ...future.rng), started = ...future.startTime, 
[01:29:32.469]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:32.469]             version = "1.8"), class = "FutureResult")
[01:29:32.469]     }, finally = {
[01:29:32.469]         if (!identical(...future.workdir, getwd())) 
[01:29:32.469]             setwd(...future.workdir)
[01:29:32.469]         {
[01:29:32.469]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:32.469]                 ...future.oldOptions$nwarnings <- NULL
[01:29:32.469]             }
[01:29:32.469]             base::options(...future.oldOptions)
[01:29:32.469]             if (.Platform$OS.type == "windows") {
[01:29:32.469]                 old_names <- names(...future.oldEnvVars)
[01:29:32.469]                 envs <- base::Sys.getenv()
[01:29:32.469]                 names <- names(envs)
[01:29:32.469]                 common <- intersect(names, old_names)
[01:29:32.469]                 added <- setdiff(names, old_names)
[01:29:32.469]                 removed <- setdiff(old_names, names)
[01:29:32.469]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:32.469]                   envs[common]]
[01:29:32.469]                 NAMES <- toupper(changed)
[01:29:32.469]                 args <- list()
[01:29:32.469]                 for (kk in seq_along(NAMES)) {
[01:29:32.469]                   name <- changed[[kk]]
[01:29:32.469]                   NAME <- NAMES[[kk]]
[01:29:32.469]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.469]                     next
[01:29:32.469]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.469]                 }
[01:29:32.469]                 NAMES <- toupper(added)
[01:29:32.469]                 for (kk in seq_along(NAMES)) {
[01:29:32.469]                   name <- added[[kk]]
[01:29:32.469]                   NAME <- NAMES[[kk]]
[01:29:32.469]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.469]                     next
[01:29:32.469]                   args[[name]] <- ""
[01:29:32.469]                 }
[01:29:32.469]                 NAMES <- toupper(removed)
[01:29:32.469]                 for (kk in seq_along(NAMES)) {
[01:29:32.469]                   name <- removed[[kk]]
[01:29:32.469]                   NAME <- NAMES[[kk]]
[01:29:32.469]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.469]                     next
[01:29:32.469]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.469]                 }
[01:29:32.469]                 if (length(args) > 0) 
[01:29:32.469]                   base::do.call(base::Sys.setenv, args = args)
[01:29:32.469]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:32.469]             }
[01:29:32.469]             else {
[01:29:32.469]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:32.469]             }
[01:29:32.469]             {
[01:29:32.469]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:32.469]                   0L) {
[01:29:32.469]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:32.469]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:32.469]                   base::options(opts)
[01:29:32.469]                 }
[01:29:32.469]                 {
[01:29:32.469]                   {
[01:29:32.469]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:32.469]                     NULL
[01:29:32.469]                   }
[01:29:32.469]                   options(future.plan = NULL)
[01:29:32.469]                   if (is.na(NA_character_)) 
[01:29:32.469]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.469]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:32.469]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:32.469]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:32.469]                     envir = parent.frame()) 
[01:29:32.469]                   {
[01:29:32.469]                     if (is.function(workers)) 
[01:29:32.469]                       workers <- workers()
[01:29:32.469]                     workers <- structure(as.integer(workers), 
[01:29:32.469]                       class = class(workers))
[01:29:32.469]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:32.469]                       workers >= 1)
[01:29:32.469]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:32.469]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:32.469]                     }
[01:29:32.469]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:32.469]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:32.469]                       envir = envir)
[01:29:32.469]                     if (!future$lazy) 
[01:29:32.469]                       future <- run(future)
[01:29:32.469]                     invisible(future)
[01:29:32.469]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:32.469]                 }
[01:29:32.469]             }
[01:29:32.469]         }
[01:29:32.469]     })
[01:29:32.469]     if (TRUE) {
[01:29:32.469]         base::sink(type = "output", split = FALSE)
[01:29:32.469]         if (TRUE) {
[01:29:32.469]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:32.469]         }
[01:29:32.469]         else {
[01:29:32.469]             ...future.result["stdout"] <- base::list(NULL)
[01:29:32.469]         }
[01:29:32.469]         base::close(...future.stdout)
[01:29:32.469]         ...future.stdout <- NULL
[01:29:32.469]     }
[01:29:32.469]     ...future.result$conditions <- ...future.conditions
[01:29:32.469]     ...future.result$finished <- base::Sys.time()
[01:29:32.469]     ...future.result
[01:29:32.469] }
[01:29:32.476] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:32.477] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:32.477] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:32.477] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:32.478] MultisessionFuture started
[01:29:32.479] - Launch lazy future ... done
[01:29:32.479] run() for 'MultisessionFuture' ... done
[01:29:32.480] getGlobalsAndPackages() ...
[01:29:32.480] Searching for globals...
[01:29:32.481] - globals found: [3] '{', 'sample', 'x'
[01:29:32.481] Searching for globals ... DONE
[01:29:32.482] Resolving globals: FALSE
[01:29:32.482] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:32.483] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:32.483] - globals: [1] 'x'
[01:29:32.483] 
[01:29:32.483] getGlobalsAndPackages() ... DONE
[01:29:32.484] run() for 'Future' ...
[01:29:32.484] - state: 'created'
[01:29:32.484] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:32.500] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:32.500] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:32.500]   - Field: 'node'
[01:29:32.500]   - Field: 'label'
[01:29:32.500]   - Field: 'local'
[01:29:32.501]   - Field: 'owner'
[01:29:32.501]   - Field: 'envir'
[01:29:32.501]   - Field: 'workers'
[01:29:32.501]   - Field: 'packages'
[01:29:32.501]   - Field: 'gc'
[01:29:32.502]   - Field: 'conditions'
[01:29:32.502]   - Field: 'persistent'
[01:29:32.502]   - Field: 'expr'
[01:29:32.502]   - Field: 'uuid'
[01:29:32.502]   - Field: 'seed'
[01:29:32.503]   - Field: 'version'
[01:29:32.503]   - Field: 'result'
[01:29:32.503]   - Field: 'asynchronous'
[01:29:32.503]   - Field: 'calls'
[01:29:32.504]   - Field: 'globals'
[01:29:32.504]   - Field: 'stdout'
[01:29:32.504]   - Field: 'earlySignal'
[01:29:32.504]   - Field: 'lazy'
[01:29:32.504]   - Field: 'state'
[01:29:32.504] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:32.505] - Launch lazy future ...
[01:29:32.505] Packages needed by the future expression (n = 0): <none>
[01:29:32.505] Packages needed by future strategies (n = 0): <none>
[01:29:32.506] {
[01:29:32.506]     {
[01:29:32.506]         {
[01:29:32.506]             ...future.startTime <- base::Sys.time()
[01:29:32.506]             {
[01:29:32.506]                 {
[01:29:32.506]                   {
[01:29:32.506]                     {
[01:29:32.506]                       base::local({
[01:29:32.506]                         has_future <- base::requireNamespace("future", 
[01:29:32.506]                           quietly = TRUE)
[01:29:32.506]                         if (has_future) {
[01:29:32.506]                           ns <- base::getNamespace("future")
[01:29:32.506]                           version <- ns[[".package"]][["version"]]
[01:29:32.506]                           if (is.null(version)) 
[01:29:32.506]                             version <- utils::packageVersion("future")
[01:29:32.506]                         }
[01:29:32.506]                         else {
[01:29:32.506]                           version <- NULL
[01:29:32.506]                         }
[01:29:32.506]                         if (!has_future || version < "1.8.0") {
[01:29:32.506]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:32.506]                             "", base::R.version$version.string), 
[01:29:32.506]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:32.506]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:32.506]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:32.506]                               "release", "version")], collapse = " "), 
[01:29:32.506]                             hostname = base::Sys.info()[["nodename"]])
[01:29:32.506]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:32.506]                             info)
[01:29:32.506]                           info <- base::paste(info, collapse = "; ")
[01:29:32.506]                           if (!has_future) {
[01:29:32.506]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:32.506]                               info)
[01:29:32.506]                           }
[01:29:32.506]                           else {
[01:29:32.506]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:32.506]                               info, version)
[01:29:32.506]                           }
[01:29:32.506]                           base::stop(msg)
[01:29:32.506]                         }
[01:29:32.506]                       })
[01:29:32.506]                     }
[01:29:32.506]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:32.506]                     base::options(mc.cores = 1L)
[01:29:32.506]                   }
[01:29:32.506]                   options(future.plan = NULL)
[01:29:32.506]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.506]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:32.506]                 }
[01:29:32.506]                 ...future.workdir <- getwd()
[01:29:32.506]             }
[01:29:32.506]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:32.506]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:32.506]         }
[01:29:32.506]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:32.506]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:32.506]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:32.506]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:32.506]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:32.506]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:32.506]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:32.506]             base::names(...future.oldOptions))
[01:29:32.506]     }
[01:29:32.506]     if (FALSE) {
[01:29:32.506]     }
[01:29:32.506]     else {
[01:29:32.506]         if (TRUE) {
[01:29:32.506]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:32.506]                 open = "w")
[01:29:32.506]         }
[01:29:32.506]         else {
[01:29:32.506]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:32.506]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:32.506]         }
[01:29:32.506]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:32.506]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:32.506]             base::sink(type = "output", split = FALSE)
[01:29:32.506]             base::close(...future.stdout)
[01:29:32.506]         }, add = TRUE)
[01:29:32.506]     }
[01:29:32.506]     ...future.frame <- base::sys.nframe()
[01:29:32.506]     ...future.conditions <- base::list()
[01:29:32.506]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:32.506]     if (FALSE) {
[01:29:32.506]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:32.506]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:32.506]     }
[01:29:32.506]     ...future.result <- base::tryCatch({
[01:29:32.506]         base::withCallingHandlers({
[01:29:32.506]             ...future.value <- base::withVisible(base::local({
[01:29:32.506]                 ...future.makeSendCondition <- base::local({
[01:29:32.506]                   sendCondition <- NULL
[01:29:32.506]                   function(frame = 1L) {
[01:29:32.506]                     if (is.function(sendCondition)) 
[01:29:32.506]                       return(sendCondition)
[01:29:32.506]                     ns <- getNamespace("parallel")
[01:29:32.506]                     if (exists("sendData", mode = "function", 
[01:29:32.506]                       envir = ns)) {
[01:29:32.506]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:32.506]                         envir = ns)
[01:29:32.506]                       envir <- sys.frame(frame)
[01:29:32.506]                       master <- NULL
[01:29:32.506]                       while (!identical(envir, .GlobalEnv) && 
[01:29:32.506]                         !identical(envir, emptyenv())) {
[01:29:32.506]                         if (exists("master", mode = "list", envir = envir, 
[01:29:32.506]                           inherits = FALSE)) {
[01:29:32.506]                           master <- get("master", mode = "list", 
[01:29:32.506]                             envir = envir, inherits = FALSE)
[01:29:32.506]                           if (inherits(master, c("SOCKnode", 
[01:29:32.506]                             "SOCK0node"))) {
[01:29:32.506]                             sendCondition <<- function(cond) {
[01:29:32.506]                               data <- list(type = "VALUE", value = cond, 
[01:29:32.506]                                 success = TRUE)
[01:29:32.506]                               parallel_sendData(master, data)
[01:29:32.506]                             }
[01:29:32.506]                             return(sendCondition)
[01:29:32.506]                           }
[01:29:32.506]                         }
[01:29:32.506]                         frame <- frame + 1L
[01:29:32.506]                         envir <- sys.frame(frame)
[01:29:32.506]                       }
[01:29:32.506]                     }
[01:29:32.506]                     sendCondition <<- function(cond) NULL
[01:29:32.506]                   }
[01:29:32.506]                 })
[01:29:32.506]                 withCallingHandlers({
[01:29:32.506]                   {
[01:29:32.506]                     sample(x, size = 1L)
[01:29:32.506]                   }
[01:29:32.506]                 }, immediateCondition = function(cond) {
[01:29:32.506]                   sendCondition <- ...future.makeSendCondition()
[01:29:32.506]                   sendCondition(cond)
[01:29:32.506]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.506]                   {
[01:29:32.506]                     inherits <- base::inherits
[01:29:32.506]                     invokeRestart <- base::invokeRestart
[01:29:32.506]                     is.null <- base::is.null
[01:29:32.506]                     muffled <- FALSE
[01:29:32.506]                     if (inherits(cond, "message")) {
[01:29:32.506]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:32.506]                       if (muffled) 
[01:29:32.506]                         invokeRestart("muffleMessage")
[01:29:32.506]                     }
[01:29:32.506]                     else if (inherits(cond, "warning")) {
[01:29:32.506]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:32.506]                       if (muffled) 
[01:29:32.506]                         invokeRestart("muffleWarning")
[01:29:32.506]                     }
[01:29:32.506]                     else if (inherits(cond, "condition")) {
[01:29:32.506]                       if (!is.null(pattern)) {
[01:29:32.506]                         computeRestarts <- base::computeRestarts
[01:29:32.506]                         grepl <- base::grepl
[01:29:32.506]                         restarts <- computeRestarts(cond)
[01:29:32.506]                         for (restart in restarts) {
[01:29:32.506]                           name <- restart$name
[01:29:32.506]                           if (is.null(name)) 
[01:29:32.506]                             next
[01:29:32.506]                           if (!grepl(pattern, name)) 
[01:29:32.506]                             next
[01:29:32.506]                           invokeRestart(restart)
[01:29:32.506]                           muffled <- TRUE
[01:29:32.506]                           break
[01:29:32.506]                         }
[01:29:32.506]                       }
[01:29:32.506]                     }
[01:29:32.506]                     invisible(muffled)
[01:29:32.506]                   }
[01:29:32.506]                   muffleCondition(cond)
[01:29:32.506]                 })
[01:29:32.506]             }))
[01:29:32.506]             future::FutureResult(value = ...future.value$value, 
[01:29:32.506]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.506]                   ...future.rng), globalenv = if (FALSE) 
[01:29:32.506]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:32.506]                     ...future.globalenv.names))
[01:29:32.506]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:32.506]         }, condition = base::local({
[01:29:32.506]             c <- base::c
[01:29:32.506]             inherits <- base::inherits
[01:29:32.506]             invokeRestart <- base::invokeRestart
[01:29:32.506]             length <- base::length
[01:29:32.506]             list <- base::list
[01:29:32.506]             seq.int <- base::seq.int
[01:29:32.506]             signalCondition <- base::signalCondition
[01:29:32.506]             sys.calls <- base::sys.calls
[01:29:32.506]             `[[` <- base::`[[`
[01:29:32.506]             `+` <- base::`+`
[01:29:32.506]             `<<-` <- base::`<<-`
[01:29:32.506]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:32.506]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:32.506]                   3L)]
[01:29:32.506]             }
[01:29:32.506]             function(cond) {
[01:29:32.506]                 is_error <- inherits(cond, "error")
[01:29:32.506]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:32.506]                   NULL)
[01:29:32.506]                 if (is_error) {
[01:29:32.506]                   sessionInformation <- function() {
[01:29:32.506]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:32.506]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:32.506]                       search = base::search(), system = base::Sys.info())
[01:29:32.506]                   }
[01:29:32.506]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.506]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:32.506]                     cond$call), session = sessionInformation(), 
[01:29:32.506]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:32.506]                   signalCondition(cond)
[01:29:32.506]                 }
[01:29:32.506]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:32.506]                 "immediateCondition"))) {
[01:29:32.506]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:32.506]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.506]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:32.506]                   if (TRUE && !signal) {
[01:29:32.506]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.506]                     {
[01:29:32.506]                       inherits <- base::inherits
[01:29:32.506]                       invokeRestart <- base::invokeRestart
[01:29:32.506]                       is.null <- base::is.null
[01:29:32.506]                       muffled <- FALSE
[01:29:32.506]                       if (inherits(cond, "message")) {
[01:29:32.506]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.506]                         if (muffled) 
[01:29:32.506]                           invokeRestart("muffleMessage")
[01:29:32.506]                       }
[01:29:32.506]                       else if (inherits(cond, "warning")) {
[01:29:32.506]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.506]                         if (muffled) 
[01:29:32.506]                           invokeRestart("muffleWarning")
[01:29:32.506]                       }
[01:29:32.506]                       else if (inherits(cond, "condition")) {
[01:29:32.506]                         if (!is.null(pattern)) {
[01:29:32.506]                           computeRestarts <- base::computeRestarts
[01:29:32.506]                           grepl <- base::grepl
[01:29:32.506]                           restarts <- computeRestarts(cond)
[01:29:32.506]                           for (restart in restarts) {
[01:29:32.506]                             name <- restart$name
[01:29:32.506]                             if (is.null(name)) 
[01:29:32.506]                               next
[01:29:32.506]                             if (!grepl(pattern, name)) 
[01:29:32.506]                               next
[01:29:32.506]                             invokeRestart(restart)
[01:29:32.506]                             muffled <- TRUE
[01:29:32.506]                             break
[01:29:32.506]                           }
[01:29:32.506]                         }
[01:29:32.506]                       }
[01:29:32.506]                       invisible(muffled)
[01:29:32.506]                     }
[01:29:32.506]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.506]                   }
[01:29:32.506]                 }
[01:29:32.506]                 else {
[01:29:32.506]                   if (TRUE) {
[01:29:32.506]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.506]                     {
[01:29:32.506]                       inherits <- base::inherits
[01:29:32.506]                       invokeRestart <- base::invokeRestart
[01:29:32.506]                       is.null <- base::is.null
[01:29:32.506]                       muffled <- FALSE
[01:29:32.506]                       if (inherits(cond, "message")) {
[01:29:32.506]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.506]                         if (muffled) 
[01:29:32.506]                           invokeRestart("muffleMessage")
[01:29:32.506]                       }
[01:29:32.506]                       else if (inherits(cond, "warning")) {
[01:29:32.506]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.506]                         if (muffled) 
[01:29:32.506]                           invokeRestart("muffleWarning")
[01:29:32.506]                       }
[01:29:32.506]                       else if (inherits(cond, "condition")) {
[01:29:32.506]                         if (!is.null(pattern)) {
[01:29:32.506]                           computeRestarts <- base::computeRestarts
[01:29:32.506]                           grepl <- base::grepl
[01:29:32.506]                           restarts <- computeRestarts(cond)
[01:29:32.506]                           for (restart in restarts) {
[01:29:32.506]                             name <- restart$name
[01:29:32.506]                             if (is.null(name)) 
[01:29:32.506]                               next
[01:29:32.506]                             if (!grepl(pattern, name)) 
[01:29:32.506]                               next
[01:29:32.506]                             invokeRestart(restart)
[01:29:32.506]                             muffled <- TRUE
[01:29:32.506]                             break
[01:29:32.506]                           }
[01:29:32.506]                         }
[01:29:32.506]                       }
[01:29:32.506]                       invisible(muffled)
[01:29:32.506]                     }
[01:29:32.506]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.506]                   }
[01:29:32.506]                 }
[01:29:32.506]             }
[01:29:32.506]         }))
[01:29:32.506]     }, error = function(ex) {
[01:29:32.506]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:32.506]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.506]                 ...future.rng), started = ...future.startTime, 
[01:29:32.506]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:32.506]             version = "1.8"), class = "FutureResult")
[01:29:32.506]     }, finally = {
[01:29:32.506]         if (!identical(...future.workdir, getwd())) 
[01:29:32.506]             setwd(...future.workdir)
[01:29:32.506]         {
[01:29:32.506]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:32.506]                 ...future.oldOptions$nwarnings <- NULL
[01:29:32.506]             }
[01:29:32.506]             base::options(...future.oldOptions)
[01:29:32.506]             if (.Platform$OS.type == "windows") {
[01:29:32.506]                 old_names <- names(...future.oldEnvVars)
[01:29:32.506]                 envs <- base::Sys.getenv()
[01:29:32.506]                 names <- names(envs)
[01:29:32.506]                 common <- intersect(names, old_names)
[01:29:32.506]                 added <- setdiff(names, old_names)
[01:29:32.506]                 removed <- setdiff(old_names, names)
[01:29:32.506]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:32.506]                   envs[common]]
[01:29:32.506]                 NAMES <- toupper(changed)
[01:29:32.506]                 args <- list()
[01:29:32.506]                 for (kk in seq_along(NAMES)) {
[01:29:32.506]                   name <- changed[[kk]]
[01:29:32.506]                   NAME <- NAMES[[kk]]
[01:29:32.506]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.506]                     next
[01:29:32.506]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.506]                 }
[01:29:32.506]                 NAMES <- toupper(added)
[01:29:32.506]                 for (kk in seq_along(NAMES)) {
[01:29:32.506]                   name <- added[[kk]]
[01:29:32.506]                   NAME <- NAMES[[kk]]
[01:29:32.506]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.506]                     next
[01:29:32.506]                   args[[name]] <- ""
[01:29:32.506]                 }
[01:29:32.506]                 NAMES <- toupper(removed)
[01:29:32.506]                 for (kk in seq_along(NAMES)) {
[01:29:32.506]                   name <- removed[[kk]]
[01:29:32.506]                   NAME <- NAMES[[kk]]
[01:29:32.506]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.506]                     next
[01:29:32.506]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.506]                 }
[01:29:32.506]                 if (length(args) > 0) 
[01:29:32.506]                   base::do.call(base::Sys.setenv, args = args)
[01:29:32.506]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:32.506]             }
[01:29:32.506]             else {
[01:29:32.506]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:32.506]             }
[01:29:32.506]             {
[01:29:32.506]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:32.506]                   0L) {
[01:29:32.506]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:32.506]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:32.506]                   base::options(opts)
[01:29:32.506]                 }
[01:29:32.506]                 {
[01:29:32.506]                   {
[01:29:32.506]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:32.506]                     NULL
[01:29:32.506]                   }
[01:29:32.506]                   options(future.plan = NULL)
[01:29:32.506]                   if (is.na(NA_character_)) 
[01:29:32.506]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.506]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:32.506]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:32.506]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:32.506]                     envir = parent.frame()) 
[01:29:32.506]                   {
[01:29:32.506]                     if (is.function(workers)) 
[01:29:32.506]                       workers <- workers()
[01:29:32.506]                     workers <- structure(as.integer(workers), 
[01:29:32.506]                       class = class(workers))
[01:29:32.506]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:32.506]                       workers >= 1)
[01:29:32.506]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:32.506]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:32.506]                     }
[01:29:32.506]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:32.506]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:32.506]                       envir = envir)
[01:29:32.506]                     if (!future$lazy) 
[01:29:32.506]                       future <- run(future)
[01:29:32.506]                     invisible(future)
[01:29:32.506]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:32.506]                 }
[01:29:32.506]             }
[01:29:32.506]         }
[01:29:32.506]     })
[01:29:32.506]     if (TRUE) {
[01:29:32.506]         base::sink(type = "output", split = FALSE)
[01:29:32.506]         if (TRUE) {
[01:29:32.506]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:32.506]         }
[01:29:32.506]         else {
[01:29:32.506]             ...future.result["stdout"] <- base::list(NULL)
[01:29:32.506]         }
[01:29:32.506]         base::close(...future.stdout)
[01:29:32.506]         ...future.stdout <- NULL
[01:29:32.506]     }
[01:29:32.506]     ...future.result$conditions <- ...future.conditions
[01:29:32.506]     ...future.result$finished <- base::Sys.time()
[01:29:32.506]     ...future.result
[01:29:32.506] }
[01:29:32.512] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:32.512] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:32.513] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:32.513] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:32.514] MultisessionFuture started
[01:29:32.514] - Launch lazy future ... done
[01:29:32.514] run() for 'MultisessionFuture' ... done
[01:29:32.515] getGlobalsAndPackages() ...
[01:29:32.515] Searching for globals...
[01:29:32.516] - globals found: [3] '{', 'sample', 'x'
[01:29:32.516] Searching for globals ... DONE
[01:29:32.517] Resolving globals: FALSE
[01:29:32.517] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:32.518] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:32.518] - globals: [1] 'x'
[01:29:32.518] 
[01:29:32.518] getGlobalsAndPackages() ... DONE
[01:29:32.519] run() for 'Future' ...
[01:29:32.519] - state: 'created'
[01:29:32.519] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:32.534] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:32.534] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:32.534]   - Field: 'node'
[01:29:32.535]   - Field: 'label'
[01:29:32.535]   - Field: 'local'
[01:29:32.535]   - Field: 'owner'
[01:29:32.535]   - Field: 'envir'
[01:29:32.535]   - Field: 'workers'
[01:29:32.536]   - Field: 'packages'
[01:29:32.536]   - Field: 'gc'
[01:29:32.536]   - Field: 'conditions'
[01:29:32.536]   - Field: 'persistent'
[01:29:32.536]   - Field: 'expr'
[01:29:32.536]   - Field: 'uuid'
[01:29:32.537]   - Field: 'seed'
[01:29:32.537]   - Field: 'version'
[01:29:32.537]   - Field: 'result'
[01:29:32.537]   - Field: 'asynchronous'
[01:29:32.537]   - Field: 'calls'
[01:29:32.537]   - Field: 'globals'
[01:29:32.538]   - Field: 'stdout'
[01:29:32.538]   - Field: 'earlySignal'
[01:29:32.538]   - Field: 'lazy'
[01:29:32.538]   - Field: 'state'
[01:29:32.538] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:32.539] - Launch lazy future ...
[01:29:32.539] Packages needed by the future expression (n = 0): <none>
[01:29:32.539] Packages needed by future strategies (n = 0): <none>
[01:29:32.540] {
[01:29:32.540]     {
[01:29:32.540]         {
[01:29:32.540]             ...future.startTime <- base::Sys.time()
[01:29:32.540]             {
[01:29:32.540]                 {
[01:29:32.540]                   {
[01:29:32.540]                     {
[01:29:32.540]                       base::local({
[01:29:32.540]                         has_future <- base::requireNamespace("future", 
[01:29:32.540]                           quietly = TRUE)
[01:29:32.540]                         if (has_future) {
[01:29:32.540]                           ns <- base::getNamespace("future")
[01:29:32.540]                           version <- ns[[".package"]][["version"]]
[01:29:32.540]                           if (is.null(version)) 
[01:29:32.540]                             version <- utils::packageVersion("future")
[01:29:32.540]                         }
[01:29:32.540]                         else {
[01:29:32.540]                           version <- NULL
[01:29:32.540]                         }
[01:29:32.540]                         if (!has_future || version < "1.8.0") {
[01:29:32.540]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:32.540]                             "", base::R.version$version.string), 
[01:29:32.540]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:32.540]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:32.540]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:32.540]                               "release", "version")], collapse = " "), 
[01:29:32.540]                             hostname = base::Sys.info()[["nodename"]])
[01:29:32.540]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:32.540]                             info)
[01:29:32.540]                           info <- base::paste(info, collapse = "; ")
[01:29:32.540]                           if (!has_future) {
[01:29:32.540]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:32.540]                               info)
[01:29:32.540]                           }
[01:29:32.540]                           else {
[01:29:32.540]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:32.540]                               info, version)
[01:29:32.540]                           }
[01:29:32.540]                           base::stop(msg)
[01:29:32.540]                         }
[01:29:32.540]                       })
[01:29:32.540]                     }
[01:29:32.540]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:32.540]                     base::options(mc.cores = 1L)
[01:29:32.540]                   }
[01:29:32.540]                   options(future.plan = NULL)
[01:29:32.540]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.540]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:32.540]                 }
[01:29:32.540]                 ...future.workdir <- getwd()
[01:29:32.540]             }
[01:29:32.540]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:32.540]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:32.540]         }
[01:29:32.540]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:32.540]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:32.540]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:32.540]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:32.540]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:32.540]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:32.540]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:32.540]             base::names(...future.oldOptions))
[01:29:32.540]     }
[01:29:32.540]     if (FALSE) {
[01:29:32.540]     }
[01:29:32.540]     else {
[01:29:32.540]         if (TRUE) {
[01:29:32.540]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:32.540]                 open = "w")
[01:29:32.540]         }
[01:29:32.540]         else {
[01:29:32.540]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:32.540]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:32.540]         }
[01:29:32.540]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:32.540]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:32.540]             base::sink(type = "output", split = FALSE)
[01:29:32.540]             base::close(...future.stdout)
[01:29:32.540]         }, add = TRUE)
[01:29:32.540]     }
[01:29:32.540]     ...future.frame <- base::sys.nframe()
[01:29:32.540]     ...future.conditions <- base::list()
[01:29:32.540]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:32.540]     if (FALSE) {
[01:29:32.540]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:32.540]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:32.540]     }
[01:29:32.540]     ...future.result <- base::tryCatch({
[01:29:32.540]         base::withCallingHandlers({
[01:29:32.540]             ...future.value <- base::withVisible(base::local({
[01:29:32.540]                 ...future.makeSendCondition <- base::local({
[01:29:32.540]                   sendCondition <- NULL
[01:29:32.540]                   function(frame = 1L) {
[01:29:32.540]                     if (is.function(sendCondition)) 
[01:29:32.540]                       return(sendCondition)
[01:29:32.540]                     ns <- getNamespace("parallel")
[01:29:32.540]                     if (exists("sendData", mode = "function", 
[01:29:32.540]                       envir = ns)) {
[01:29:32.540]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:32.540]                         envir = ns)
[01:29:32.540]                       envir <- sys.frame(frame)
[01:29:32.540]                       master <- NULL
[01:29:32.540]                       while (!identical(envir, .GlobalEnv) && 
[01:29:32.540]                         !identical(envir, emptyenv())) {
[01:29:32.540]                         if (exists("master", mode = "list", envir = envir, 
[01:29:32.540]                           inherits = FALSE)) {
[01:29:32.540]                           master <- get("master", mode = "list", 
[01:29:32.540]                             envir = envir, inherits = FALSE)
[01:29:32.540]                           if (inherits(master, c("SOCKnode", 
[01:29:32.540]                             "SOCK0node"))) {
[01:29:32.540]                             sendCondition <<- function(cond) {
[01:29:32.540]                               data <- list(type = "VALUE", value = cond, 
[01:29:32.540]                                 success = TRUE)
[01:29:32.540]                               parallel_sendData(master, data)
[01:29:32.540]                             }
[01:29:32.540]                             return(sendCondition)
[01:29:32.540]                           }
[01:29:32.540]                         }
[01:29:32.540]                         frame <- frame + 1L
[01:29:32.540]                         envir <- sys.frame(frame)
[01:29:32.540]                       }
[01:29:32.540]                     }
[01:29:32.540]                     sendCondition <<- function(cond) NULL
[01:29:32.540]                   }
[01:29:32.540]                 })
[01:29:32.540]                 withCallingHandlers({
[01:29:32.540]                   {
[01:29:32.540]                     sample(x, size = 1L)
[01:29:32.540]                   }
[01:29:32.540]                 }, immediateCondition = function(cond) {
[01:29:32.540]                   sendCondition <- ...future.makeSendCondition()
[01:29:32.540]                   sendCondition(cond)
[01:29:32.540]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.540]                   {
[01:29:32.540]                     inherits <- base::inherits
[01:29:32.540]                     invokeRestart <- base::invokeRestart
[01:29:32.540]                     is.null <- base::is.null
[01:29:32.540]                     muffled <- FALSE
[01:29:32.540]                     if (inherits(cond, "message")) {
[01:29:32.540]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:32.540]                       if (muffled) 
[01:29:32.540]                         invokeRestart("muffleMessage")
[01:29:32.540]                     }
[01:29:32.540]                     else if (inherits(cond, "warning")) {
[01:29:32.540]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:32.540]                       if (muffled) 
[01:29:32.540]                         invokeRestart("muffleWarning")
[01:29:32.540]                     }
[01:29:32.540]                     else if (inherits(cond, "condition")) {
[01:29:32.540]                       if (!is.null(pattern)) {
[01:29:32.540]                         computeRestarts <- base::computeRestarts
[01:29:32.540]                         grepl <- base::grepl
[01:29:32.540]                         restarts <- computeRestarts(cond)
[01:29:32.540]                         for (restart in restarts) {
[01:29:32.540]                           name <- restart$name
[01:29:32.540]                           if (is.null(name)) 
[01:29:32.540]                             next
[01:29:32.540]                           if (!grepl(pattern, name)) 
[01:29:32.540]                             next
[01:29:32.540]                           invokeRestart(restart)
[01:29:32.540]                           muffled <- TRUE
[01:29:32.540]                           break
[01:29:32.540]                         }
[01:29:32.540]                       }
[01:29:32.540]                     }
[01:29:32.540]                     invisible(muffled)
[01:29:32.540]                   }
[01:29:32.540]                   muffleCondition(cond)
[01:29:32.540]                 })
[01:29:32.540]             }))
[01:29:32.540]             future::FutureResult(value = ...future.value$value, 
[01:29:32.540]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.540]                   ...future.rng), globalenv = if (FALSE) 
[01:29:32.540]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:32.540]                     ...future.globalenv.names))
[01:29:32.540]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:32.540]         }, condition = base::local({
[01:29:32.540]             c <- base::c
[01:29:32.540]             inherits <- base::inherits
[01:29:32.540]             invokeRestart <- base::invokeRestart
[01:29:32.540]             length <- base::length
[01:29:32.540]             list <- base::list
[01:29:32.540]             seq.int <- base::seq.int
[01:29:32.540]             signalCondition <- base::signalCondition
[01:29:32.540]             sys.calls <- base::sys.calls
[01:29:32.540]             `[[` <- base::`[[`
[01:29:32.540]             `+` <- base::`+`
[01:29:32.540]             `<<-` <- base::`<<-`
[01:29:32.540]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:32.540]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:32.540]                   3L)]
[01:29:32.540]             }
[01:29:32.540]             function(cond) {
[01:29:32.540]                 is_error <- inherits(cond, "error")
[01:29:32.540]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:32.540]                   NULL)
[01:29:32.540]                 if (is_error) {
[01:29:32.540]                   sessionInformation <- function() {
[01:29:32.540]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:32.540]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:32.540]                       search = base::search(), system = base::Sys.info())
[01:29:32.540]                   }
[01:29:32.540]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.540]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:32.540]                     cond$call), session = sessionInformation(), 
[01:29:32.540]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:32.540]                   signalCondition(cond)
[01:29:32.540]                 }
[01:29:32.540]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:32.540]                 "immediateCondition"))) {
[01:29:32.540]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:32.540]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.540]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:32.540]                   if (TRUE && !signal) {
[01:29:32.540]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.540]                     {
[01:29:32.540]                       inherits <- base::inherits
[01:29:32.540]                       invokeRestart <- base::invokeRestart
[01:29:32.540]                       is.null <- base::is.null
[01:29:32.540]                       muffled <- FALSE
[01:29:32.540]                       if (inherits(cond, "message")) {
[01:29:32.540]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.540]                         if (muffled) 
[01:29:32.540]                           invokeRestart("muffleMessage")
[01:29:32.540]                       }
[01:29:32.540]                       else if (inherits(cond, "warning")) {
[01:29:32.540]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.540]                         if (muffled) 
[01:29:32.540]                           invokeRestart("muffleWarning")
[01:29:32.540]                       }
[01:29:32.540]                       else if (inherits(cond, "condition")) {
[01:29:32.540]                         if (!is.null(pattern)) {
[01:29:32.540]                           computeRestarts <- base::computeRestarts
[01:29:32.540]                           grepl <- base::grepl
[01:29:32.540]                           restarts <- computeRestarts(cond)
[01:29:32.540]                           for (restart in restarts) {
[01:29:32.540]                             name <- restart$name
[01:29:32.540]                             if (is.null(name)) 
[01:29:32.540]                               next
[01:29:32.540]                             if (!grepl(pattern, name)) 
[01:29:32.540]                               next
[01:29:32.540]                             invokeRestart(restart)
[01:29:32.540]                             muffled <- TRUE
[01:29:32.540]                             break
[01:29:32.540]                           }
[01:29:32.540]                         }
[01:29:32.540]                       }
[01:29:32.540]                       invisible(muffled)
[01:29:32.540]                     }
[01:29:32.540]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.540]                   }
[01:29:32.540]                 }
[01:29:32.540]                 else {
[01:29:32.540]                   if (TRUE) {
[01:29:32.540]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.540]                     {
[01:29:32.540]                       inherits <- base::inherits
[01:29:32.540]                       invokeRestart <- base::invokeRestart
[01:29:32.540]                       is.null <- base::is.null
[01:29:32.540]                       muffled <- FALSE
[01:29:32.540]                       if (inherits(cond, "message")) {
[01:29:32.540]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.540]                         if (muffled) 
[01:29:32.540]                           invokeRestart("muffleMessage")
[01:29:32.540]                       }
[01:29:32.540]                       else if (inherits(cond, "warning")) {
[01:29:32.540]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.540]                         if (muffled) 
[01:29:32.540]                           invokeRestart("muffleWarning")
[01:29:32.540]                       }
[01:29:32.540]                       else if (inherits(cond, "condition")) {
[01:29:32.540]                         if (!is.null(pattern)) {
[01:29:32.540]                           computeRestarts <- base::computeRestarts
[01:29:32.540]                           grepl <- base::grepl
[01:29:32.540]                           restarts <- computeRestarts(cond)
[01:29:32.540]                           for (restart in restarts) {
[01:29:32.540]                             name <- restart$name
[01:29:32.540]                             if (is.null(name)) 
[01:29:32.540]                               next
[01:29:32.540]                             if (!grepl(pattern, name)) 
[01:29:32.540]                               next
[01:29:32.540]                             invokeRestart(restart)
[01:29:32.540]                             muffled <- TRUE
[01:29:32.540]                             break
[01:29:32.540]                           }
[01:29:32.540]                         }
[01:29:32.540]                       }
[01:29:32.540]                       invisible(muffled)
[01:29:32.540]                     }
[01:29:32.540]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.540]                   }
[01:29:32.540]                 }
[01:29:32.540]             }
[01:29:32.540]         }))
[01:29:32.540]     }, error = function(ex) {
[01:29:32.540]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:32.540]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.540]                 ...future.rng), started = ...future.startTime, 
[01:29:32.540]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:32.540]             version = "1.8"), class = "FutureResult")
[01:29:32.540]     }, finally = {
[01:29:32.540]         if (!identical(...future.workdir, getwd())) 
[01:29:32.540]             setwd(...future.workdir)
[01:29:32.540]         {
[01:29:32.540]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:32.540]                 ...future.oldOptions$nwarnings <- NULL
[01:29:32.540]             }
[01:29:32.540]             base::options(...future.oldOptions)
[01:29:32.540]             if (.Platform$OS.type == "windows") {
[01:29:32.540]                 old_names <- names(...future.oldEnvVars)
[01:29:32.540]                 envs <- base::Sys.getenv()
[01:29:32.540]                 names <- names(envs)
[01:29:32.540]                 common <- intersect(names, old_names)
[01:29:32.540]                 added <- setdiff(names, old_names)
[01:29:32.540]                 removed <- setdiff(old_names, names)
[01:29:32.540]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:32.540]                   envs[common]]
[01:29:32.540]                 NAMES <- toupper(changed)
[01:29:32.540]                 args <- list()
[01:29:32.540]                 for (kk in seq_along(NAMES)) {
[01:29:32.540]                   name <- changed[[kk]]
[01:29:32.540]                   NAME <- NAMES[[kk]]
[01:29:32.540]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.540]                     next
[01:29:32.540]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.540]                 }
[01:29:32.540]                 NAMES <- toupper(added)
[01:29:32.540]                 for (kk in seq_along(NAMES)) {
[01:29:32.540]                   name <- added[[kk]]
[01:29:32.540]                   NAME <- NAMES[[kk]]
[01:29:32.540]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.540]                     next
[01:29:32.540]                   args[[name]] <- ""
[01:29:32.540]                 }
[01:29:32.540]                 NAMES <- toupper(removed)
[01:29:32.540]                 for (kk in seq_along(NAMES)) {
[01:29:32.540]                   name <- removed[[kk]]
[01:29:32.540]                   NAME <- NAMES[[kk]]
[01:29:32.540]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.540]                     next
[01:29:32.540]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.540]                 }
[01:29:32.540]                 if (length(args) > 0) 
[01:29:32.540]                   base::do.call(base::Sys.setenv, args = args)
[01:29:32.540]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:32.540]             }
[01:29:32.540]             else {
[01:29:32.540]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:32.540]             }
[01:29:32.540]             {
[01:29:32.540]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:32.540]                   0L) {
[01:29:32.540]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:32.540]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:32.540]                   base::options(opts)
[01:29:32.540]                 }
[01:29:32.540]                 {
[01:29:32.540]                   {
[01:29:32.540]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:32.540]                     NULL
[01:29:32.540]                   }
[01:29:32.540]                   options(future.plan = NULL)
[01:29:32.540]                   if (is.na(NA_character_)) 
[01:29:32.540]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.540]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:32.540]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:32.540]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:32.540]                     envir = parent.frame()) 
[01:29:32.540]                   {
[01:29:32.540]                     if (is.function(workers)) 
[01:29:32.540]                       workers <- workers()
[01:29:32.540]                     workers <- structure(as.integer(workers), 
[01:29:32.540]                       class = class(workers))
[01:29:32.540]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:32.540]                       workers >= 1)
[01:29:32.540]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:32.540]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:32.540]                     }
[01:29:32.540]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:32.540]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:32.540]                       envir = envir)
[01:29:32.540]                     if (!future$lazy) 
[01:29:32.540]                       future <- run(future)
[01:29:32.540]                     invisible(future)
[01:29:32.540]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:32.540]                 }
[01:29:32.540]             }
[01:29:32.540]         }
[01:29:32.540]     })
[01:29:32.540]     if (TRUE) {
[01:29:32.540]         base::sink(type = "output", split = FALSE)
[01:29:32.540]         if (TRUE) {
[01:29:32.540]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:32.540]         }
[01:29:32.540]         else {
[01:29:32.540]             ...future.result["stdout"] <- base::list(NULL)
[01:29:32.540]         }
[01:29:32.540]         base::close(...future.stdout)
[01:29:32.540]         ...future.stdout <- NULL
[01:29:32.540]     }
[01:29:32.540]     ...future.result$conditions <- ...future.conditions
[01:29:32.540]     ...future.result$finished <- base::Sys.time()
[01:29:32.540]     ...future.result
[01:29:32.540] }
[01:29:32.545] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:32.565] receiveMessageFromWorker() for ClusterFuture ...
[01:29:32.565] - Validating connection of MultisessionFuture
[01:29:32.566] - received message: FutureResult
[01:29:32.566] - Received FutureResult
[01:29:32.566] - Erased future from FutureRegistry
[01:29:32.566] result() for ClusterFuture ...
[01:29:32.567] - result already collected: FutureResult
[01:29:32.567] result() for ClusterFuture ... done
[01:29:32.567] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:32.567] result() for ClusterFuture ...
[01:29:32.567] - result already collected: FutureResult
[01:29:32.567] result() for ClusterFuture ... done
[01:29:32.568] result() for ClusterFuture ...
[01:29:32.568] - result already collected: FutureResult
[01:29:32.568] result() for ClusterFuture ... done
[01:29:32.569] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:32.569] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:32.570] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:32.570] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:32.571] MultisessionFuture started
[01:29:32.571] - Launch lazy future ... done
[01:29:32.571] run() for 'MultisessionFuture' ... done
[01:29:32.572] getGlobalsAndPackages() ...
[01:29:32.572] Searching for globals...
[01:29:32.578] - globals found: [3] '{', 'sample', 'x'
[01:29:32.578] Searching for globals ... DONE
[01:29:32.578] Resolving globals: FALSE
[01:29:32.579] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:32.579] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:32.580] - globals: [1] 'x'
[01:29:32.580] 
[01:29:32.580] getGlobalsAndPackages() ... DONE
[01:29:32.580] run() for 'Future' ...
[01:29:32.581] - state: 'created'
[01:29:32.581] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:32.595] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:32.595] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:32.596]   - Field: 'node'
[01:29:32.596]   - Field: 'label'
[01:29:32.596]   - Field: 'local'
[01:29:32.596]   - Field: 'owner'
[01:29:32.596]   - Field: 'envir'
[01:29:32.597]   - Field: 'workers'
[01:29:32.597]   - Field: 'packages'
[01:29:32.597]   - Field: 'gc'
[01:29:32.597]   - Field: 'conditions'
[01:29:32.597]   - Field: 'persistent'
[01:29:32.598]   - Field: 'expr'
[01:29:32.598]   - Field: 'uuid'
[01:29:32.598]   - Field: 'seed'
[01:29:32.598]   - Field: 'version'
[01:29:32.598]   - Field: 'result'
[01:29:32.598]   - Field: 'asynchronous'
[01:29:32.599]   - Field: 'calls'
[01:29:32.599]   - Field: 'globals'
[01:29:32.599]   - Field: 'stdout'
[01:29:32.599]   - Field: 'earlySignal'
[01:29:32.599]   - Field: 'lazy'
[01:29:32.600]   - Field: 'state'
[01:29:32.600] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:32.600] - Launch lazy future ...
[01:29:32.600] Packages needed by the future expression (n = 0): <none>
[01:29:32.601] Packages needed by future strategies (n = 0): <none>
[01:29:32.601] {
[01:29:32.601]     {
[01:29:32.601]         {
[01:29:32.601]             ...future.startTime <- base::Sys.time()
[01:29:32.601]             {
[01:29:32.601]                 {
[01:29:32.601]                   {
[01:29:32.601]                     {
[01:29:32.601]                       base::local({
[01:29:32.601]                         has_future <- base::requireNamespace("future", 
[01:29:32.601]                           quietly = TRUE)
[01:29:32.601]                         if (has_future) {
[01:29:32.601]                           ns <- base::getNamespace("future")
[01:29:32.601]                           version <- ns[[".package"]][["version"]]
[01:29:32.601]                           if (is.null(version)) 
[01:29:32.601]                             version <- utils::packageVersion("future")
[01:29:32.601]                         }
[01:29:32.601]                         else {
[01:29:32.601]                           version <- NULL
[01:29:32.601]                         }
[01:29:32.601]                         if (!has_future || version < "1.8.0") {
[01:29:32.601]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:32.601]                             "", base::R.version$version.string), 
[01:29:32.601]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:32.601]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:32.601]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:32.601]                               "release", "version")], collapse = " "), 
[01:29:32.601]                             hostname = base::Sys.info()[["nodename"]])
[01:29:32.601]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:32.601]                             info)
[01:29:32.601]                           info <- base::paste(info, collapse = "; ")
[01:29:32.601]                           if (!has_future) {
[01:29:32.601]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:32.601]                               info)
[01:29:32.601]                           }
[01:29:32.601]                           else {
[01:29:32.601]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:32.601]                               info, version)
[01:29:32.601]                           }
[01:29:32.601]                           base::stop(msg)
[01:29:32.601]                         }
[01:29:32.601]                       })
[01:29:32.601]                     }
[01:29:32.601]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:32.601]                     base::options(mc.cores = 1L)
[01:29:32.601]                   }
[01:29:32.601]                   options(future.plan = NULL)
[01:29:32.601]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.601]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:32.601]                 }
[01:29:32.601]                 ...future.workdir <- getwd()
[01:29:32.601]             }
[01:29:32.601]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:32.601]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:32.601]         }
[01:29:32.601]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:32.601]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:32.601]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:32.601]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:32.601]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:32.601]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:32.601]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:32.601]             base::names(...future.oldOptions))
[01:29:32.601]     }
[01:29:32.601]     if (FALSE) {
[01:29:32.601]     }
[01:29:32.601]     else {
[01:29:32.601]         if (TRUE) {
[01:29:32.601]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:32.601]                 open = "w")
[01:29:32.601]         }
[01:29:32.601]         else {
[01:29:32.601]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:32.601]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:32.601]         }
[01:29:32.601]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:32.601]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:32.601]             base::sink(type = "output", split = FALSE)
[01:29:32.601]             base::close(...future.stdout)
[01:29:32.601]         }, add = TRUE)
[01:29:32.601]     }
[01:29:32.601]     ...future.frame <- base::sys.nframe()
[01:29:32.601]     ...future.conditions <- base::list()
[01:29:32.601]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:32.601]     if (FALSE) {
[01:29:32.601]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:32.601]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:32.601]     }
[01:29:32.601]     ...future.result <- base::tryCatch({
[01:29:32.601]         base::withCallingHandlers({
[01:29:32.601]             ...future.value <- base::withVisible(base::local({
[01:29:32.601]                 ...future.makeSendCondition <- base::local({
[01:29:32.601]                   sendCondition <- NULL
[01:29:32.601]                   function(frame = 1L) {
[01:29:32.601]                     if (is.function(sendCondition)) 
[01:29:32.601]                       return(sendCondition)
[01:29:32.601]                     ns <- getNamespace("parallel")
[01:29:32.601]                     if (exists("sendData", mode = "function", 
[01:29:32.601]                       envir = ns)) {
[01:29:32.601]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:32.601]                         envir = ns)
[01:29:32.601]                       envir <- sys.frame(frame)
[01:29:32.601]                       master <- NULL
[01:29:32.601]                       while (!identical(envir, .GlobalEnv) && 
[01:29:32.601]                         !identical(envir, emptyenv())) {
[01:29:32.601]                         if (exists("master", mode = "list", envir = envir, 
[01:29:32.601]                           inherits = FALSE)) {
[01:29:32.601]                           master <- get("master", mode = "list", 
[01:29:32.601]                             envir = envir, inherits = FALSE)
[01:29:32.601]                           if (inherits(master, c("SOCKnode", 
[01:29:32.601]                             "SOCK0node"))) {
[01:29:32.601]                             sendCondition <<- function(cond) {
[01:29:32.601]                               data <- list(type = "VALUE", value = cond, 
[01:29:32.601]                                 success = TRUE)
[01:29:32.601]                               parallel_sendData(master, data)
[01:29:32.601]                             }
[01:29:32.601]                             return(sendCondition)
[01:29:32.601]                           }
[01:29:32.601]                         }
[01:29:32.601]                         frame <- frame + 1L
[01:29:32.601]                         envir <- sys.frame(frame)
[01:29:32.601]                       }
[01:29:32.601]                     }
[01:29:32.601]                     sendCondition <<- function(cond) NULL
[01:29:32.601]                   }
[01:29:32.601]                 })
[01:29:32.601]                 withCallingHandlers({
[01:29:32.601]                   {
[01:29:32.601]                     sample(x, size = 1L)
[01:29:32.601]                   }
[01:29:32.601]                 }, immediateCondition = function(cond) {
[01:29:32.601]                   sendCondition <- ...future.makeSendCondition()
[01:29:32.601]                   sendCondition(cond)
[01:29:32.601]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.601]                   {
[01:29:32.601]                     inherits <- base::inherits
[01:29:32.601]                     invokeRestart <- base::invokeRestart
[01:29:32.601]                     is.null <- base::is.null
[01:29:32.601]                     muffled <- FALSE
[01:29:32.601]                     if (inherits(cond, "message")) {
[01:29:32.601]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:32.601]                       if (muffled) 
[01:29:32.601]                         invokeRestart("muffleMessage")
[01:29:32.601]                     }
[01:29:32.601]                     else if (inherits(cond, "warning")) {
[01:29:32.601]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:32.601]                       if (muffled) 
[01:29:32.601]                         invokeRestart("muffleWarning")
[01:29:32.601]                     }
[01:29:32.601]                     else if (inherits(cond, "condition")) {
[01:29:32.601]                       if (!is.null(pattern)) {
[01:29:32.601]                         computeRestarts <- base::computeRestarts
[01:29:32.601]                         grepl <- base::grepl
[01:29:32.601]                         restarts <- computeRestarts(cond)
[01:29:32.601]                         for (restart in restarts) {
[01:29:32.601]                           name <- restart$name
[01:29:32.601]                           if (is.null(name)) 
[01:29:32.601]                             next
[01:29:32.601]                           if (!grepl(pattern, name)) 
[01:29:32.601]                             next
[01:29:32.601]                           invokeRestart(restart)
[01:29:32.601]                           muffled <- TRUE
[01:29:32.601]                           break
[01:29:32.601]                         }
[01:29:32.601]                       }
[01:29:32.601]                     }
[01:29:32.601]                     invisible(muffled)
[01:29:32.601]                   }
[01:29:32.601]                   muffleCondition(cond)
[01:29:32.601]                 })
[01:29:32.601]             }))
[01:29:32.601]             future::FutureResult(value = ...future.value$value, 
[01:29:32.601]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.601]                   ...future.rng), globalenv = if (FALSE) 
[01:29:32.601]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:32.601]                     ...future.globalenv.names))
[01:29:32.601]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:32.601]         }, condition = base::local({
[01:29:32.601]             c <- base::c
[01:29:32.601]             inherits <- base::inherits
[01:29:32.601]             invokeRestart <- base::invokeRestart
[01:29:32.601]             length <- base::length
[01:29:32.601]             list <- base::list
[01:29:32.601]             seq.int <- base::seq.int
[01:29:32.601]             signalCondition <- base::signalCondition
[01:29:32.601]             sys.calls <- base::sys.calls
[01:29:32.601]             `[[` <- base::`[[`
[01:29:32.601]             `+` <- base::`+`
[01:29:32.601]             `<<-` <- base::`<<-`
[01:29:32.601]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:32.601]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:32.601]                   3L)]
[01:29:32.601]             }
[01:29:32.601]             function(cond) {
[01:29:32.601]                 is_error <- inherits(cond, "error")
[01:29:32.601]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:32.601]                   NULL)
[01:29:32.601]                 if (is_error) {
[01:29:32.601]                   sessionInformation <- function() {
[01:29:32.601]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:32.601]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:32.601]                       search = base::search(), system = base::Sys.info())
[01:29:32.601]                   }
[01:29:32.601]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.601]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:32.601]                     cond$call), session = sessionInformation(), 
[01:29:32.601]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:32.601]                   signalCondition(cond)
[01:29:32.601]                 }
[01:29:32.601]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:32.601]                 "immediateCondition"))) {
[01:29:32.601]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:32.601]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.601]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:32.601]                   if (TRUE && !signal) {
[01:29:32.601]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.601]                     {
[01:29:32.601]                       inherits <- base::inherits
[01:29:32.601]                       invokeRestart <- base::invokeRestart
[01:29:32.601]                       is.null <- base::is.null
[01:29:32.601]                       muffled <- FALSE
[01:29:32.601]                       if (inherits(cond, "message")) {
[01:29:32.601]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.601]                         if (muffled) 
[01:29:32.601]                           invokeRestart("muffleMessage")
[01:29:32.601]                       }
[01:29:32.601]                       else if (inherits(cond, "warning")) {
[01:29:32.601]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.601]                         if (muffled) 
[01:29:32.601]                           invokeRestart("muffleWarning")
[01:29:32.601]                       }
[01:29:32.601]                       else if (inherits(cond, "condition")) {
[01:29:32.601]                         if (!is.null(pattern)) {
[01:29:32.601]                           computeRestarts <- base::computeRestarts
[01:29:32.601]                           grepl <- base::grepl
[01:29:32.601]                           restarts <- computeRestarts(cond)
[01:29:32.601]                           for (restart in restarts) {
[01:29:32.601]                             name <- restart$name
[01:29:32.601]                             if (is.null(name)) 
[01:29:32.601]                               next
[01:29:32.601]                             if (!grepl(pattern, name)) 
[01:29:32.601]                               next
[01:29:32.601]                             invokeRestart(restart)
[01:29:32.601]                             muffled <- TRUE
[01:29:32.601]                             break
[01:29:32.601]                           }
[01:29:32.601]                         }
[01:29:32.601]                       }
[01:29:32.601]                       invisible(muffled)
[01:29:32.601]                     }
[01:29:32.601]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.601]                   }
[01:29:32.601]                 }
[01:29:32.601]                 else {
[01:29:32.601]                   if (TRUE) {
[01:29:32.601]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.601]                     {
[01:29:32.601]                       inherits <- base::inherits
[01:29:32.601]                       invokeRestart <- base::invokeRestart
[01:29:32.601]                       is.null <- base::is.null
[01:29:32.601]                       muffled <- FALSE
[01:29:32.601]                       if (inherits(cond, "message")) {
[01:29:32.601]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.601]                         if (muffled) 
[01:29:32.601]                           invokeRestart("muffleMessage")
[01:29:32.601]                       }
[01:29:32.601]                       else if (inherits(cond, "warning")) {
[01:29:32.601]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.601]                         if (muffled) 
[01:29:32.601]                           invokeRestart("muffleWarning")
[01:29:32.601]                       }
[01:29:32.601]                       else if (inherits(cond, "condition")) {
[01:29:32.601]                         if (!is.null(pattern)) {
[01:29:32.601]                           computeRestarts <- base::computeRestarts
[01:29:32.601]                           grepl <- base::grepl
[01:29:32.601]                           restarts <- computeRestarts(cond)
[01:29:32.601]                           for (restart in restarts) {
[01:29:32.601]                             name <- restart$name
[01:29:32.601]                             if (is.null(name)) 
[01:29:32.601]                               next
[01:29:32.601]                             if (!grepl(pattern, name)) 
[01:29:32.601]                               next
[01:29:32.601]                             invokeRestart(restart)
[01:29:32.601]                             muffled <- TRUE
[01:29:32.601]                             break
[01:29:32.601]                           }
[01:29:32.601]                         }
[01:29:32.601]                       }
[01:29:32.601]                       invisible(muffled)
[01:29:32.601]                     }
[01:29:32.601]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.601]                   }
[01:29:32.601]                 }
[01:29:32.601]             }
[01:29:32.601]         }))
[01:29:32.601]     }, error = function(ex) {
[01:29:32.601]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:32.601]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.601]                 ...future.rng), started = ...future.startTime, 
[01:29:32.601]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:32.601]             version = "1.8"), class = "FutureResult")
[01:29:32.601]     }, finally = {
[01:29:32.601]         if (!identical(...future.workdir, getwd())) 
[01:29:32.601]             setwd(...future.workdir)
[01:29:32.601]         {
[01:29:32.601]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:32.601]                 ...future.oldOptions$nwarnings <- NULL
[01:29:32.601]             }
[01:29:32.601]             base::options(...future.oldOptions)
[01:29:32.601]             if (.Platform$OS.type == "windows") {
[01:29:32.601]                 old_names <- names(...future.oldEnvVars)
[01:29:32.601]                 envs <- base::Sys.getenv()
[01:29:32.601]                 names <- names(envs)
[01:29:32.601]                 common <- intersect(names, old_names)
[01:29:32.601]                 added <- setdiff(names, old_names)
[01:29:32.601]                 removed <- setdiff(old_names, names)
[01:29:32.601]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:32.601]                   envs[common]]
[01:29:32.601]                 NAMES <- toupper(changed)
[01:29:32.601]                 args <- list()
[01:29:32.601]                 for (kk in seq_along(NAMES)) {
[01:29:32.601]                   name <- changed[[kk]]
[01:29:32.601]                   NAME <- NAMES[[kk]]
[01:29:32.601]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.601]                     next
[01:29:32.601]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.601]                 }
[01:29:32.601]                 NAMES <- toupper(added)
[01:29:32.601]                 for (kk in seq_along(NAMES)) {
[01:29:32.601]                   name <- added[[kk]]
[01:29:32.601]                   NAME <- NAMES[[kk]]
[01:29:32.601]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.601]                     next
[01:29:32.601]                   args[[name]] <- ""
[01:29:32.601]                 }
[01:29:32.601]                 NAMES <- toupper(removed)
[01:29:32.601]                 for (kk in seq_along(NAMES)) {
[01:29:32.601]                   name <- removed[[kk]]
[01:29:32.601]                   NAME <- NAMES[[kk]]
[01:29:32.601]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.601]                     next
[01:29:32.601]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.601]                 }
[01:29:32.601]                 if (length(args) > 0) 
[01:29:32.601]                   base::do.call(base::Sys.setenv, args = args)
[01:29:32.601]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:32.601]             }
[01:29:32.601]             else {
[01:29:32.601]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:32.601]             }
[01:29:32.601]             {
[01:29:32.601]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:32.601]                   0L) {
[01:29:32.601]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:32.601]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:32.601]                   base::options(opts)
[01:29:32.601]                 }
[01:29:32.601]                 {
[01:29:32.601]                   {
[01:29:32.601]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:32.601]                     NULL
[01:29:32.601]                   }
[01:29:32.601]                   options(future.plan = NULL)
[01:29:32.601]                   if (is.na(NA_character_)) 
[01:29:32.601]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.601]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:32.601]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:32.601]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:32.601]                     envir = parent.frame()) 
[01:29:32.601]                   {
[01:29:32.601]                     if (is.function(workers)) 
[01:29:32.601]                       workers <- workers()
[01:29:32.601]                     workers <- structure(as.integer(workers), 
[01:29:32.601]                       class = class(workers))
[01:29:32.601]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:32.601]                       workers >= 1)
[01:29:32.601]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:32.601]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:32.601]                     }
[01:29:32.601]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:32.601]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:32.601]                       envir = envir)
[01:29:32.601]                     if (!future$lazy) 
[01:29:32.601]                       future <- run(future)
[01:29:32.601]                     invisible(future)
[01:29:32.601]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:32.601]                 }
[01:29:32.601]             }
[01:29:32.601]         }
[01:29:32.601]     })
[01:29:32.601]     if (TRUE) {
[01:29:32.601]         base::sink(type = "output", split = FALSE)
[01:29:32.601]         if (TRUE) {
[01:29:32.601]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:32.601]         }
[01:29:32.601]         else {
[01:29:32.601]             ...future.result["stdout"] <- base::list(NULL)
[01:29:32.601]         }
[01:29:32.601]         base::close(...future.stdout)
[01:29:32.601]         ...future.stdout <- NULL
[01:29:32.601]     }
[01:29:32.601]     ...future.result$conditions <- ...future.conditions
[01:29:32.601]     ...future.result$finished <- base::Sys.time()
[01:29:32.601]     ...future.result
[01:29:32.601] }
[01:29:32.606] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:32.629] receiveMessageFromWorker() for ClusterFuture ...
[01:29:32.630] - Validating connection of MultisessionFuture
[01:29:32.630] - received message: FutureResult
[01:29:32.630] - Received FutureResult
[01:29:32.630] - Erased future from FutureRegistry
[01:29:32.631] result() for ClusterFuture ...
[01:29:32.631] - result already collected: FutureResult
[01:29:32.631] result() for ClusterFuture ... done
[01:29:32.631] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:32.631] result() for ClusterFuture ...
[01:29:32.632] - result already collected: FutureResult
[01:29:32.632] result() for ClusterFuture ... done
[01:29:32.632] result() for ClusterFuture ...
[01:29:32.632] - result already collected: FutureResult
[01:29:32.632] result() for ClusterFuture ... done
[01:29:32.634] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:32.634] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:32.635] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:32.635] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:32.636] MultisessionFuture started
[01:29:32.636] - Launch lazy future ... done
[01:29:32.636] run() for 'MultisessionFuture' ... done
[01:29:32.637] result() for ClusterFuture ...
[01:29:32.637] - result already collected: FutureResult
[01:29:32.637] result() for ClusterFuture ... done
[01:29:32.637] result() for ClusterFuture ...
[01:29:32.638] - result already collected: FutureResult
[01:29:32.638] result() for ClusterFuture ... done
[01:29:32.638] signalConditions() ...
[01:29:32.638]  - include = 'immediateCondition'
[01:29:32.638]  - exclude = 
[01:29:32.638]  - resignal = FALSE
[01:29:32.639]  - Number of conditions: 1
[01:29:32.639] signalConditions() ... done
[01:29:32.639] Future state: 'finished'
[01:29:32.639] result() for ClusterFuture ...
[01:29:32.639] - result already collected: FutureResult
[01:29:32.640] result() for ClusterFuture ... done
[01:29:32.640] signalConditions() ...
[01:29:32.640]  - include = 'condition'
[01:29:32.640]  - exclude = 'immediateCondition'
[01:29:32.640]  - resignal = TRUE
[01:29:32.640]  - Number of conditions: 1
[01:29:32.641]  - Condition #1: 'RngFutureWarning', 'FutureWarning', 'warning', 'RngFutureCondition', 'FutureCondition', 'condition'
[01:29:32.641] signalConditions() ... done
<RngFutureWarning: UNRELIABLE VALUE: Future ('fsample_1-682326') unexpectedly generated random numbers without specifying argument 'seed'. There is a risk that those random numbers are not statistically sound and the overall results might be invalid. To fix this, specify 'seed=TRUE'. This ensures that proper, parallel-safe random numbers are produced via the L'Ecuyer-CMRG method. To disable this check, use 'seed=NULL', or set option 'future.rng.onMisuse' to "ignore".>


Future UUID: 1f15eb46-03ec-43e2-8bb0-47ac9275bde2


DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
MultisessionFuture:
Label: 'fsample_1-682326'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b9704041f0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Conditions captured: [n=1] 'RngFutureWarning'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'

DEBUG: END TROUBLESHOOTING HELP
[01:29:32.643] getGlobalsAndPackages() ...
[01:29:32.643] Searching for globals...
[01:29:32.645] - globals found: [3] '{', 'sample', 'x'
[01:29:32.645] Searching for globals ... DONE
[01:29:32.645] Resolving globals: FALSE
[01:29:32.646] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:32.646] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:32.646] - globals: [1] 'x'
[01:29:32.647] 
[01:29:32.647] getGlobalsAndPackages() ... DONE
[01:29:32.647] run() for 'Future' ...
[01:29:32.647] - state: 'created'
[01:29:32.648] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:32.663] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:32.664] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:32.664]   - Field: 'node'
[01:29:32.664]   - Field: 'label'
[01:29:32.664]   - Field: 'local'
[01:29:32.664]   - Field: 'owner'
[01:29:32.665]   - Field: 'envir'
[01:29:32.665]   - Field: 'workers'
[01:29:32.665]   - Field: 'packages'
[01:29:32.665]   - Field: 'gc'
[01:29:32.666]   - Field: 'conditions'
[01:29:32.666]   - Field: 'persistent'
[01:29:32.666]   - Field: 'expr'
[01:29:32.666]   - Field: 'uuid'
[01:29:32.666]   - Field: 'seed'
[01:29:32.666]   - Field: 'version'
[01:29:32.667]   - Field: 'result'
[01:29:32.667]   - Field: 'asynchronous'
[01:29:32.667]   - Field: 'calls'
[01:29:32.667]   - Field: 'globals'
[01:29:32.668]   - Field: 'stdout'
[01:29:32.668]   - Field: 'earlySignal'
[01:29:32.668]   - Field: 'lazy'
[01:29:32.668]   - Field: 'state'
[01:29:32.668] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:32.669] - Launch lazy future ...
[01:29:32.669] Packages needed by the future expression (n = 0): <none>
[01:29:32.669] Packages needed by future strategies (n = 0): <none>
[01:29:32.670] {
[01:29:32.670]     {
[01:29:32.670]         {
[01:29:32.670]             ...future.startTime <- base::Sys.time()
[01:29:32.670]             {
[01:29:32.670]                 {
[01:29:32.670]                   {
[01:29:32.670]                     {
[01:29:32.670]                       base::local({
[01:29:32.670]                         has_future <- base::requireNamespace("future", 
[01:29:32.670]                           quietly = TRUE)
[01:29:32.670]                         if (has_future) {
[01:29:32.670]                           ns <- base::getNamespace("future")
[01:29:32.670]                           version <- ns[[".package"]][["version"]]
[01:29:32.670]                           if (is.null(version)) 
[01:29:32.670]                             version <- utils::packageVersion("future")
[01:29:32.670]                         }
[01:29:32.670]                         else {
[01:29:32.670]                           version <- NULL
[01:29:32.670]                         }
[01:29:32.670]                         if (!has_future || version < "1.8.0") {
[01:29:32.670]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:32.670]                             "", base::R.version$version.string), 
[01:29:32.670]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:32.670]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:32.670]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:32.670]                               "release", "version")], collapse = " "), 
[01:29:32.670]                             hostname = base::Sys.info()[["nodename"]])
[01:29:32.670]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:32.670]                             info)
[01:29:32.670]                           info <- base::paste(info, collapse = "; ")
[01:29:32.670]                           if (!has_future) {
[01:29:32.670]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:32.670]                               info)
[01:29:32.670]                           }
[01:29:32.670]                           else {
[01:29:32.670]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:32.670]                               info, version)
[01:29:32.670]                           }
[01:29:32.670]                           base::stop(msg)
[01:29:32.670]                         }
[01:29:32.670]                       })
[01:29:32.670]                     }
[01:29:32.670]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:32.670]                     base::options(mc.cores = 1L)
[01:29:32.670]                   }
[01:29:32.670]                   options(future.plan = NULL)
[01:29:32.670]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.670]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:32.670]                 }
[01:29:32.670]                 ...future.workdir <- getwd()
[01:29:32.670]             }
[01:29:32.670]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:32.670]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:32.670]         }
[01:29:32.670]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:32.670]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:32.670]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:32.670]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:32.670]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:32.670]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:32.670]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:32.670]             base::names(...future.oldOptions))
[01:29:32.670]     }
[01:29:32.670]     if (FALSE) {
[01:29:32.670]     }
[01:29:32.670]     else {
[01:29:32.670]         if (TRUE) {
[01:29:32.670]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:32.670]                 open = "w")
[01:29:32.670]         }
[01:29:32.670]         else {
[01:29:32.670]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:32.670]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:32.670]         }
[01:29:32.670]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:32.670]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:32.670]             base::sink(type = "output", split = FALSE)
[01:29:32.670]             base::close(...future.stdout)
[01:29:32.670]         }, add = TRUE)
[01:29:32.670]     }
[01:29:32.670]     ...future.frame <- base::sys.nframe()
[01:29:32.670]     ...future.conditions <- base::list()
[01:29:32.670]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:32.670]     if (FALSE) {
[01:29:32.670]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:32.670]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:32.670]     }
[01:29:32.670]     ...future.result <- base::tryCatch({
[01:29:32.670]         base::withCallingHandlers({
[01:29:32.670]             ...future.value <- base::withVisible(base::local({
[01:29:32.670]                 ...future.makeSendCondition <- base::local({
[01:29:32.670]                   sendCondition <- NULL
[01:29:32.670]                   function(frame = 1L) {
[01:29:32.670]                     if (is.function(sendCondition)) 
[01:29:32.670]                       return(sendCondition)
[01:29:32.670]                     ns <- getNamespace("parallel")
[01:29:32.670]                     if (exists("sendData", mode = "function", 
[01:29:32.670]                       envir = ns)) {
[01:29:32.670]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:32.670]                         envir = ns)
[01:29:32.670]                       envir <- sys.frame(frame)
[01:29:32.670]                       master <- NULL
[01:29:32.670]                       while (!identical(envir, .GlobalEnv) && 
[01:29:32.670]                         !identical(envir, emptyenv())) {
[01:29:32.670]                         if (exists("master", mode = "list", envir = envir, 
[01:29:32.670]                           inherits = FALSE)) {
[01:29:32.670]                           master <- get("master", mode = "list", 
[01:29:32.670]                             envir = envir, inherits = FALSE)
[01:29:32.670]                           if (inherits(master, c("SOCKnode", 
[01:29:32.670]                             "SOCK0node"))) {
[01:29:32.670]                             sendCondition <<- function(cond) {
[01:29:32.670]                               data <- list(type = "VALUE", value = cond, 
[01:29:32.670]                                 success = TRUE)
[01:29:32.670]                               parallel_sendData(master, data)
[01:29:32.670]                             }
[01:29:32.670]                             return(sendCondition)
[01:29:32.670]                           }
[01:29:32.670]                         }
[01:29:32.670]                         frame <- frame + 1L
[01:29:32.670]                         envir <- sys.frame(frame)
[01:29:32.670]                       }
[01:29:32.670]                     }
[01:29:32.670]                     sendCondition <<- function(cond) NULL
[01:29:32.670]                   }
[01:29:32.670]                 })
[01:29:32.670]                 withCallingHandlers({
[01:29:32.670]                   {
[01:29:32.670]                     sample(x, size = 1L)
[01:29:32.670]                   }
[01:29:32.670]                 }, immediateCondition = function(cond) {
[01:29:32.670]                   sendCondition <- ...future.makeSendCondition()
[01:29:32.670]                   sendCondition(cond)
[01:29:32.670]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.670]                   {
[01:29:32.670]                     inherits <- base::inherits
[01:29:32.670]                     invokeRestart <- base::invokeRestart
[01:29:32.670]                     is.null <- base::is.null
[01:29:32.670]                     muffled <- FALSE
[01:29:32.670]                     if (inherits(cond, "message")) {
[01:29:32.670]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:32.670]                       if (muffled) 
[01:29:32.670]                         invokeRestart("muffleMessage")
[01:29:32.670]                     }
[01:29:32.670]                     else if (inherits(cond, "warning")) {
[01:29:32.670]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:32.670]                       if (muffled) 
[01:29:32.670]                         invokeRestart("muffleWarning")
[01:29:32.670]                     }
[01:29:32.670]                     else if (inherits(cond, "condition")) {
[01:29:32.670]                       if (!is.null(pattern)) {
[01:29:32.670]                         computeRestarts <- base::computeRestarts
[01:29:32.670]                         grepl <- base::grepl
[01:29:32.670]                         restarts <- computeRestarts(cond)
[01:29:32.670]                         for (restart in restarts) {
[01:29:32.670]                           name <- restart$name
[01:29:32.670]                           if (is.null(name)) 
[01:29:32.670]                             next
[01:29:32.670]                           if (!grepl(pattern, name)) 
[01:29:32.670]                             next
[01:29:32.670]                           invokeRestart(restart)
[01:29:32.670]                           muffled <- TRUE
[01:29:32.670]                           break
[01:29:32.670]                         }
[01:29:32.670]                       }
[01:29:32.670]                     }
[01:29:32.670]                     invisible(muffled)
[01:29:32.670]                   }
[01:29:32.670]                   muffleCondition(cond)
[01:29:32.670]                 })
[01:29:32.670]             }))
[01:29:32.670]             future::FutureResult(value = ...future.value$value, 
[01:29:32.670]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.670]                   ...future.rng), globalenv = if (FALSE) 
[01:29:32.670]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:32.670]                     ...future.globalenv.names))
[01:29:32.670]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:32.670]         }, condition = base::local({
[01:29:32.670]             c <- base::c
[01:29:32.670]             inherits <- base::inherits
[01:29:32.670]             invokeRestart <- base::invokeRestart
[01:29:32.670]             length <- base::length
[01:29:32.670]             list <- base::list
[01:29:32.670]             seq.int <- base::seq.int
[01:29:32.670]             signalCondition <- base::signalCondition
[01:29:32.670]             sys.calls <- base::sys.calls
[01:29:32.670]             `[[` <- base::`[[`
[01:29:32.670]             `+` <- base::`+`
[01:29:32.670]             `<<-` <- base::`<<-`
[01:29:32.670]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:32.670]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:32.670]                   3L)]
[01:29:32.670]             }
[01:29:32.670]             function(cond) {
[01:29:32.670]                 is_error <- inherits(cond, "error")
[01:29:32.670]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:32.670]                   NULL)
[01:29:32.670]                 if (is_error) {
[01:29:32.670]                   sessionInformation <- function() {
[01:29:32.670]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:32.670]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:32.670]                       search = base::search(), system = base::Sys.info())
[01:29:32.670]                   }
[01:29:32.670]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.670]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:32.670]                     cond$call), session = sessionInformation(), 
[01:29:32.670]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:32.670]                   signalCondition(cond)
[01:29:32.670]                 }
[01:29:32.670]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:32.670]                 "immediateCondition"))) {
[01:29:32.670]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:32.670]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.670]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:32.670]                   if (TRUE && !signal) {
[01:29:32.670]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.670]                     {
[01:29:32.670]                       inherits <- base::inherits
[01:29:32.670]                       invokeRestart <- base::invokeRestart
[01:29:32.670]                       is.null <- base::is.null
[01:29:32.670]                       muffled <- FALSE
[01:29:32.670]                       if (inherits(cond, "message")) {
[01:29:32.670]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.670]                         if (muffled) 
[01:29:32.670]                           invokeRestart("muffleMessage")
[01:29:32.670]                       }
[01:29:32.670]                       else if (inherits(cond, "warning")) {
[01:29:32.670]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.670]                         if (muffled) 
[01:29:32.670]                           invokeRestart("muffleWarning")
[01:29:32.670]                       }
[01:29:32.670]                       else if (inherits(cond, "condition")) {
[01:29:32.670]                         if (!is.null(pattern)) {
[01:29:32.670]                           computeRestarts <- base::computeRestarts
[01:29:32.670]                           grepl <- base::grepl
[01:29:32.670]                           restarts <- computeRestarts(cond)
[01:29:32.670]                           for (restart in restarts) {
[01:29:32.670]                             name <- restart$name
[01:29:32.670]                             if (is.null(name)) 
[01:29:32.670]                               next
[01:29:32.670]                             if (!grepl(pattern, name)) 
[01:29:32.670]                               next
[01:29:32.670]                             invokeRestart(restart)
[01:29:32.670]                             muffled <- TRUE
[01:29:32.670]                             break
[01:29:32.670]                           }
[01:29:32.670]                         }
[01:29:32.670]                       }
[01:29:32.670]                       invisible(muffled)
[01:29:32.670]                     }
[01:29:32.670]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.670]                   }
[01:29:32.670]                 }
[01:29:32.670]                 else {
[01:29:32.670]                   if (TRUE) {
[01:29:32.670]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.670]                     {
[01:29:32.670]                       inherits <- base::inherits
[01:29:32.670]                       invokeRestart <- base::invokeRestart
[01:29:32.670]                       is.null <- base::is.null
[01:29:32.670]                       muffled <- FALSE
[01:29:32.670]                       if (inherits(cond, "message")) {
[01:29:32.670]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.670]                         if (muffled) 
[01:29:32.670]                           invokeRestart("muffleMessage")
[01:29:32.670]                       }
[01:29:32.670]                       else if (inherits(cond, "warning")) {
[01:29:32.670]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.670]                         if (muffled) 
[01:29:32.670]                           invokeRestart("muffleWarning")
[01:29:32.670]                       }
[01:29:32.670]                       else if (inherits(cond, "condition")) {
[01:29:32.670]                         if (!is.null(pattern)) {
[01:29:32.670]                           computeRestarts <- base::computeRestarts
[01:29:32.670]                           grepl <- base::grepl
[01:29:32.670]                           restarts <- computeRestarts(cond)
[01:29:32.670]                           for (restart in restarts) {
[01:29:32.670]                             name <- restart$name
[01:29:32.670]                             if (is.null(name)) 
[01:29:32.670]                               next
[01:29:32.670]                             if (!grepl(pattern, name)) 
[01:29:32.670]                               next
[01:29:32.670]                             invokeRestart(restart)
[01:29:32.670]                             muffled <- TRUE
[01:29:32.670]                             break
[01:29:32.670]                           }
[01:29:32.670]                         }
[01:29:32.670]                       }
[01:29:32.670]                       invisible(muffled)
[01:29:32.670]                     }
[01:29:32.670]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.670]                   }
[01:29:32.670]                 }
[01:29:32.670]             }
[01:29:32.670]         }))
[01:29:32.670]     }, error = function(ex) {
[01:29:32.670]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:32.670]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.670]                 ...future.rng), started = ...future.startTime, 
[01:29:32.670]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:32.670]             version = "1.8"), class = "FutureResult")
[01:29:32.670]     }, finally = {
[01:29:32.670]         if (!identical(...future.workdir, getwd())) 
[01:29:32.670]             setwd(...future.workdir)
[01:29:32.670]         {
[01:29:32.670]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:32.670]                 ...future.oldOptions$nwarnings <- NULL
[01:29:32.670]             }
[01:29:32.670]             base::options(...future.oldOptions)
[01:29:32.670]             if (.Platform$OS.type == "windows") {
[01:29:32.670]                 old_names <- names(...future.oldEnvVars)
[01:29:32.670]                 envs <- base::Sys.getenv()
[01:29:32.670]                 names <- names(envs)
[01:29:32.670]                 common <- intersect(names, old_names)
[01:29:32.670]                 added <- setdiff(names, old_names)
[01:29:32.670]                 removed <- setdiff(old_names, names)
[01:29:32.670]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:32.670]                   envs[common]]
[01:29:32.670]                 NAMES <- toupper(changed)
[01:29:32.670]                 args <- list()
[01:29:32.670]                 for (kk in seq_along(NAMES)) {
[01:29:32.670]                   name <- changed[[kk]]
[01:29:32.670]                   NAME <- NAMES[[kk]]
[01:29:32.670]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.670]                     next
[01:29:32.670]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.670]                 }
[01:29:32.670]                 NAMES <- toupper(added)
[01:29:32.670]                 for (kk in seq_along(NAMES)) {
[01:29:32.670]                   name <- added[[kk]]
[01:29:32.670]                   NAME <- NAMES[[kk]]
[01:29:32.670]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.670]                     next
[01:29:32.670]                   args[[name]] <- ""
[01:29:32.670]                 }
[01:29:32.670]                 NAMES <- toupper(removed)
[01:29:32.670]                 for (kk in seq_along(NAMES)) {
[01:29:32.670]                   name <- removed[[kk]]
[01:29:32.670]                   NAME <- NAMES[[kk]]
[01:29:32.670]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.670]                     next
[01:29:32.670]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.670]                 }
[01:29:32.670]                 if (length(args) > 0) 
[01:29:32.670]                   base::do.call(base::Sys.setenv, args = args)
[01:29:32.670]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:32.670]             }
[01:29:32.670]             else {
[01:29:32.670]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:32.670]             }
[01:29:32.670]             {
[01:29:32.670]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:32.670]                   0L) {
[01:29:32.670]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:32.670]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:32.670]                   base::options(opts)
[01:29:32.670]                 }
[01:29:32.670]                 {
[01:29:32.670]                   {
[01:29:32.670]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:32.670]                     NULL
[01:29:32.670]                   }
[01:29:32.670]                   options(future.plan = NULL)
[01:29:32.670]                   if (is.na(NA_character_)) 
[01:29:32.670]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.670]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:32.670]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:32.670]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:32.670]                     envir = parent.frame()) 
[01:29:32.670]                   {
[01:29:32.670]                     if (is.function(workers)) 
[01:29:32.670]                       workers <- workers()
[01:29:32.670]                     workers <- structure(as.integer(workers), 
[01:29:32.670]                       class = class(workers))
[01:29:32.670]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:32.670]                       workers >= 1)
[01:29:32.670]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:32.670]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:32.670]                     }
[01:29:32.670]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:32.670]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:32.670]                       envir = envir)
[01:29:32.670]                     if (!future$lazy) 
[01:29:32.670]                       future <- run(future)
[01:29:32.670]                     invisible(future)
[01:29:32.670]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:32.670]                 }
[01:29:32.670]             }
[01:29:32.670]         }
[01:29:32.670]     })
[01:29:32.670]     if (TRUE) {
[01:29:32.670]         base::sink(type = "output", split = FALSE)
[01:29:32.670]         if (TRUE) {
[01:29:32.670]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:32.670]         }
[01:29:32.670]         else {
[01:29:32.670]             ...future.result["stdout"] <- base::list(NULL)
[01:29:32.670]         }
[01:29:32.670]         base::close(...future.stdout)
[01:29:32.670]         ...future.stdout <- NULL
[01:29:32.670]     }
[01:29:32.670]     ...future.result$conditions <- ...future.conditions
[01:29:32.670]     ...future.result$finished <- base::Sys.time()
[01:29:32.670]     ...future.result
[01:29:32.670] }
[01:29:32.675] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:32.690] receiveMessageFromWorker() for ClusterFuture ...
[01:29:32.691] - Validating connection of MultisessionFuture
[01:29:32.691] - received message: FutureResult
[01:29:32.691] - Received FutureResult
[01:29:32.692] - Erased future from FutureRegistry
[01:29:32.692] result() for ClusterFuture ...
[01:29:32.692] - result already collected: FutureResult
[01:29:32.692] result() for ClusterFuture ... done
[01:29:32.692] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:32.693] result() for ClusterFuture ...
[01:29:32.693] - result already collected: FutureResult
[01:29:32.693] result() for ClusterFuture ... done
[01:29:32.693] result() for ClusterFuture ...
[01:29:32.693] - result already collected: FutureResult
[01:29:32.694] result() for ClusterFuture ... done
[01:29:32.695] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:32.695] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:32.696] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:32.696] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:32.697] MultisessionFuture started
[01:29:32.697] - Launch lazy future ... done
[01:29:32.697] run() for 'MultisessionFuture' ... done
[01:29:32.698] getGlobalsAndPackages() ...
[01:29:32.698] Searching for globals...
[01:29:32.700] - globals found: [3] '{', 'sample', 'x'
[01:29:32.700] Searching for globals ... DONE
[01:29:32.700] Resolving globals: FALSE
[01:29:32.701] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:32.701] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:32.701] - globals: [1] 'x'
[01:29:32.702] 
[01:29:32.702] getGlobalsAndPackages() ... DONE
[01:29:32.702] run() for 'Future' ...
[01:29:32.702] - state: 'created'
[01:29:32.703] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:32.717] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:32.717] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:32.717]   - Field: 'node'
[01:29:32.718]   - Field: 'label'
[01:29:32.718]   - Field: 'local'
[01:29:32.718]   - Field: 'owner'
[01:29:32.718]   - Field: 'envir'
[01:29:32.718]   - Field: 'workers'
[01:29:32.719]   - Field: 'packages'
[01:29:32.719]   - Field: 'gc'
[01:29:32.719]   - Field: 'conditions'
[01:29:32.719]   - Field: 'persistent'
[01:29:32.719]   - Field: 'expr'
[01:29:32.719]   - Field: 'uuid'
[01:29:32.720]   - Field: 'seed'
[01:29:32.720]   - Field: 'version'
[01:29:32.720]   - Field: 'result'
[01:29:32.720]   - Field: 'asynchronous'
[01:29:32.720]   - Field: 'calls'
[01:29:32.721]   - Field: 'globals'
[01:29:32.721]   - Field: 'stdout'
[01:29:32.721]   - Field: 'earlySignal'
[01:29:32.721]   - Field: 'lazy'
[01:29:32.722]   - Field: 'state'
[01:29:32.722] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:32.722] - Launch lazy future ...
[01:29:32.722] Packages needed by the future expression (n = 0): <none>
[01:29:32.723] Packages needed by future strategies (n = 0): <none>
[01:29:32.723] {
[01:29:32.723]     {
[01:29:32.723]         {
[01:29:32.723]             ...future.startTime <- base::Sys.time()
[01:29:32.723]             {
[01:29:32.723]                 {
[01:29:32.723]                   {
[01:29:32.723]                     {
[01:29:32.723]                       base::local({
[01:29:32.723]                         has_future <- base::requireNamespace("future", 
[01:29:32.723]                           quietly = TRUE)
[01:29:32.723]                         if (has_future) {
[01:29:32.723]                           ns <- base::getNamespace("future")
[01:29:32.723]                           version <- ns[[".package"]][["version"]]
[01:29:32.723]                           if (is.null(version)) 
[01:29:32.723]                             version <- utils::packageVersion("future")
[01:29:32.723]                         }
[01:29:32.723]                         else {
[01:29:32.723]                           version <- NULL
[01:29:32.723]                         }
[01:29:32.723]                         if (!has_future || version < "1.8.0") {
[01:29:32.723]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:32.723]                             "", base::R.version$version.string), 
[01:29:32.723]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:32.723]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:32.723]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:32.723]                               "release", "version")], collapse = " "), 
[01:29:32.723]                             hostname = base::Sys.info()[["nodename"]])
[01:29:32.723]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:32.723]                             info)
[01:29:32.723]                           info <- base::paste(info, collapse = "; ")
[01:29:32.723]                           if (!has_future) {
[01:29:32.723]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:32.723]                               info)
[01:29:32.723]                           }
[01:29:32.723]                           else {
[01:29:32.723]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:32.723]                               info, version)
[01:29:32.723]                           }
[01:29:32.723]                           base::stop(msg)
[01:29:32.723]                         }
[01:29:32.723]                       })
[01:29:32.723]                     }
[01:29:32.723]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:32.723]                     base::options(mc.cores = 1L)
[01:29:32.723]                   }
[01:29:32.723]                   options(future.plan = NULL)
[01:29:32.723]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.723]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:32.723]                 }
[01:29:32.723]                 ...future.workdir <- getwd()
[01:29:32.723]             }
[01:29:32.723]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:32.723]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:32.723]         }
[01:29:32.723]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:32.723]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:32.723]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:32.723]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:32.723]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:32.723]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:32.723]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:32.723]             base::names(...future.oldOptions))
[01:29:32.723]     }
[01:29:32.723]     if (FALSE) {
[01:29:32.723]     }
[01:29:32.723]     else {
[01:29:32.723]         if (TRUE) {
[01:29:32.723]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:32.723]                 open = "w")
[01:29:32.723]         }
[01:29:32.723]         else {
[01:29:32.723]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:32.723]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:32.723]         }
[01:29:32.723]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:32.723]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:32.723]             base::sink(type = "output", split = FALSE)
[01:29:32.723]             base::close(...future.stdout)
[01:29:32.723]         }, add = TRUE)
[01:29:32.723]     }
[01:29:32.723]     ...future.frame <- base::sys.nframe()
[01:29:32.723]     ...future.conditions <- base::list()
[01:29:32.723]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:32.723]     if (FALSE) {
[01:29:32.723]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:32.723]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:32.723]     }
[01:29:32.723]     ...future.result <- base::tryCatch({
[01:29:32.723]         base::withCallingHandlers({
[01:29:32.723]             ...future.value <- base::withVisible(base::local({
[01:29:32.723]                 ...future.makeSendCondition <- base::local({
[01:29:32.723]                   sendCondition <- NULL
[01:29:32.723]                   function(frame = 1L) {
[01:29:32.723]                     if (is.function(sendCondition)) 
[01:29:32.723]                       return(sendCondition)
[01:29:32.723]                     ns <- getNamespace("parallel")
[01:29:32.723]                     if (exists("sendData", mode = "function", 
[01:29:32.723]                       envir = ns)) {
[01:29:32.723]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:32.723]                         envir = ns)
[01:29:32.723]                       envir <- sys.frame(frame)
[01:29:32.723]                       master <- NULL
[01:29:32.723]                       while (!identical(envir, .GlobalEnv) && 
[01:29:32.723]                         !identical(envir, emptyenv())) {
[01:29:32.723]                         if (exists("master", mode = "list", envir = envir, 
[01:29:32.723]                           inherits = FALSE)) {
[01:29:32.723]                           master <- get("master", mode = "list", 
[01:29:32.723]                             envir = envir, inherits = FALSE)
[01:29:32.723]                           if (inherits(master, c("SOCKnode", 
[01:29:32.723]                             "SOCK0node"))) {
[01:29:32.723]                             sendCondition <<- function(cond) {
[01:29:32.723]                               data <- list(type = "VALUE", value = cond, 
[01:29:32.723]                                 success = TRUE)
[01:29:32.723]                               parallel_sendData(master, data)
[01:29:32.723]                             }
[01:29:32.723]                             return(sendCondition)
[01:29:32.723]                           }
[01:29:32.723]                         }
[01:29:32.723]                         frame <- frame + 1L
[01:29:32.723]                         envir <- sys.frame(frame)
[01:29:32.723]                       }
[01:29:32.723]                     }
[01:29:32.723]                     sendCondition <<- function(cond) NULL
[01:29:32.723]                   }
[01:29:32.723]                 })
[01:29:32.723]                 withCallingHandlers({
[01:29:32.723]                   {
[01:29:32.723]                     sample(x, size = 1L)
[01:29:32.723]                   }
[01:29:32.723]                 }, immediateCondition = function(cond) {
[01:29:32.723]                   sendCondition <- ...future.makeSendCondition()
[01:29:32.723]                   sendCondition(cond)
[01:29:32.723]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.723]                   {
[01:29:32.723]                     inherits <- base::inherits
[01:29:32.723]                     invokeRestart <- base::invokeRestart
[01:29:32.723]                     is.null <- base::is.null
[01:29:32.723]                     muffled <- FALSE
[01:29:32.723]                     if (inherits(cond, "message")) {
[01:29:32.723]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:32.723]                       if (muffled) 
[01:29:32.723]                         invokeRestart("muffleMessage")
[01:29:32.723]                     }
[01:29:32.723]                     else if (inherits(cond, "warning")) {
[01:29:32.723]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:32.723]                       if (muffled) 
[01:29:32.723]                         invokeRestart("muffleWarning")
[01:29:32.723]                     }
[01:29:32.723]                     else if (inherits(cond, "condition")) {
[01:29:32.723]                       if (!is.null(pattern)) {
[01:29:32.723]                         computeRestarts <- base::computeRestarts
[01:29:32.723]                         grepl <- base::grepl
[01:29:32.723]                         restarts <- computeRestarts(cond)
[01:29:32.723]                         for (restart in restarts) {
[01:29:32.723]                           name <- restart$name
[01:29:32.723]                           if (is.null(name)) 
[01:29:32.723]                             next
[01:29:32.723]                           if (!grepl(pattern, name)) 
[01:29:32.723]                             next
[01:29:32.723]                           invokeRestart(restart)
[01:29:32.723]                           muffled <- TRUE
[01:29:32.723]                           break
[01:29:32.723]                         }
[01:29:32.723]                       }
[01:29:32.723]                     }
[01:29:32.723]                     invisible(muffled)
[01:29:32.723]                   }
[01:29:32.723]                   muffleCondition(cond)
[01:29:32.723]                 })
[01:29:32.723]             }))
[01:29:32.723]             future::FutureResult(value = ...future.value$value, 
[01:29:32.723]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.723]                   ...future.rng), globalenv = if (FALSE) 
[01:29:32.723]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:32.723]                     ...future.globalenv.names))
[01:29:32.723]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:32.723]         }, condition = base::local({
[01:29:32.723]             c <- base::c
[01:29:32.723]             inherits <- base::inherits
[01:29:32.723]             invokeRestart <- base::invokeRestart
[01:29:32.723]             length <- base::length
[01:29:32.723]             list <- base::list
[01:29:32.723]             seq.int <- base::seq.int
[01:29:32.723]             signalCondition <- base::signalCondition
[01:29:32.723]             sys.calls <- base::sys.calls
[01:29:32.723]             `[[` <- base::`[[`
[01:29:32.723]             `+` <- base::`+`
[01:29:32.723]             `<<-` <- base::`<<-`
[01:29:32.723]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:32.723]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:32.723]                   3L)]
[01:29:32.723]             }
[01:29:32.723]             function(cond) {
[01:29:32.723]                 is_error <- inherits(cond, "error")
[01:29:32.723]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:32.723]                   NULL)
[01:29:32.723]                 if (is_error) {
[01:29:32.723]                   sessionInformation <- function() {
[01:29:32.723]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:32.723]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:32.723]                       search = base::search(), system = base::Sys.info())
[01:29:32.723]                   }
[01:29:32.723]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.723]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:32.723]                     cond$call), session = sessionInformation(), 
[01:29:32.723]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:32.723]                   signalCondition(cond)
[01:29:32.723]                 }
[01:29:32.723]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:32.723]                 "immediateCondition"))) {
[01:29:32.723]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:32.723]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.723]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:32.723]                   if (TRUE && !signal) {
[01:29:32.723]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.723]                     {
[01:29:32.723]                       inherits <- base::inherits
[01:29:32.723]                       invokeRestart <- base::invokeRestart
[01:29:32.723]                       is.null <- base::is.null
[01:29:32.723]                       muffled <- FALSE
[01:29:32.723]                       if (inherits(cond, "message")) {
[01:29:32.723]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.723]                         if (muffled) 
[01:29:32.723]                           invokeRestart("muffleMessage")
[01:29:32.723]                       }
[01:29:32.723]                       else if (inherits(cond, "warning")) {
[01:29:32.723]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.723]                         if (muffled) 
[01:29:32.723]                           invokeRestart("muffleWarning")
[01:29:32.723]                       }
[01:29:32.723]                       else if (inherits(cond, "condition")) {
[01:29:32.723]                         if (!is.null(pattern)) {
[01:29:32.723]                           computeRestarts <- base::computeRestarts
[01:29:32.723]                           grepl <- base::grepl
[01:29:32.723]                           restarts <- computeRestarts(cond)
[01:29:32.723]                           for (restart in restarts) {
[01:29:32.723]                             name <- restart$name
[01:29:32.723]                             if (is.null(name)) 
[01:29:32.723]                               next
[01:29:32.723]                             if (!grepl(pattern, name)) 
[01:29:32.723]                               next
[01:29:32.723]                             invokeRestart(restart)
[01:29:32.723]                             muffled <- TRUE
[01:29:32.723]                             break
[01:29:32.723]                           }
[01:29:32.723]                         }
[01:29:32.723]                       }
[01:29:32.723]                       invisible(muffled)
[01:29:32.723]                     }
[01:29:32.723]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.723]                   }
[01:29:32.723]                 }
[01:29:32.723]                 else {
[01:29:32.723]                   if (TRUE) {
[01:29:32.723]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.723]                     {
[01:29:32.723]                       inherits <- base::inherits
[01:29:32.723]                       invokeRestart <- base::invokeRestart
[01:29:32.723]                       is.null <- base::is.null
[01:29:32.723]                       muffled <- FALSE
[01:29:32.723]                       if (inherits(cond, "message")) {
[01:29:32.723]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.723]                         if (muffled) 
[01:29:32.723]                           invokeRestart("muffleMessage")
[01:29:32.723]                       }
[01:29:32.723]                       else if (inherits(cond, "warning")) {
[01:29:32.723]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.723]                         if (muffled) 
[01:29:32.723]                           invokeRestart("muffleWarning")
[01:29:32.723]                       }
[01:29:32.723]                       else if (inherits(cond, "condition")) {
[01:29:32.723]                         if (!is.null(pattern)) {
[01:29:32.723]                           computeRestarts <- base::computeRestarts
[01:29:32.723]                           grepl <- base::grepl
[01:29:32.723]                           restarts <- computeRestarts(cond)
[01:29:32.723]                           for (restart in restarts) {
[01:29:32.723]                             name <- restart$name
[01:29:32.723]                             if (is.null(name)) 
[01:29:32.723]                               next
[01:29:32.723]                             if (!grepl(pattern, name)) 
[01:29:32.723]                               next
[01:29:32.723]                             invokeRestart(restart)
[01:29:32.723]                             muffled <- TRUE
[01:29:32.723]                             break
[01:29:32.723]                           }
[01:29:32.723]                         }
[01:29:32.723]                       }
[01:29:32.723]                       invisible(muffled)
[01:29:32.723]                     }
[01:29:32.723]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.723]                   }
[01:29:32.723]                 }
[01:29:32.723]             }
[01:29:32.723]         }))
[01:29:32.723]     }, error = function(ex) {
[01:29:32.723]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:32.723]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.723]                 ...future.rng), started = ...future.startTime, 
[01:29:32.723]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:32.723]             version = "1.8"), class = "FutureResult")
[01:29:32.723]     }, finally = {
[01:29:32.723]         if (!identical(...future.workdir, getwd())) 
[01:29:32.723]             setwd(...future.workdir)
[01:29:32.723]         {
[01:29:32.723]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:32.723]                 ...future.oldOptions$nwarnings <- NULL
[01:29:32.723]             }
[01:29:32.723]             base::options(...future.oldOptions)
[01:29:32.723]             if (.Platform$OS.type == "windows") {
[01:29:32.723]                 old_names <- names(...future.oldEnvVars)
[01:29:32.723]                 envs <- base::Sys.getenv()
[01:29:32.723]                 names <- names(envs)
[01:29:32.723]                 common <- intersect(names, old_names)
[01:29:32.723]                 added <- setdiff(names, old_names)
[01:29:32.723]                 removed <- setdiff(old_names, names)
[01:29:32.723]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:32.723]                   envs[common]]
[01:29:32.723]                 NAMES <- toupper(changed)
[01:29:32.723]                 args <- list()
[01:29:32.723]                 for (kk in seq_along(NAMES)) {
[01:29:32.723]                   name <- changed[[kk]]
[01:29:32.723]                   NAME <- NAMES[[kk]]
[01:29:32.723]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.723]                     next
[01:29:32.723]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.723]                 }
[01:29:32.723]                 NAMES <- toupper(added)
[01:29:32.723]                 for (kk in seq_along(NAMES)) {
[01:29:32.723]                   name <- added[[kk]]
[01:29:32.723]                   NAME <- NAMES[[kk]]
[01:29:32.723]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.723]                     next
[01:29:32.723]                   args[[name]] <- ""
[01:29:32.723]                 }
[01:29:32.723]                 NAMES <- toupper(removed)
[01:29:32.723]                 for (kk in seq_along(NAMES)) {
[01:29:32.723]                   name <- removed[[kk]]
[01:29:32.723]                   NAME <- NAMES[[kk]]
[01:29:32.723]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.723]                     next
[01:29:32.723]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.723]                 }
[01:29:32.723]                 if (length(args) > 0) 
[01:29:32.723]                   base::do.call(base::Sys.setenv, args = args)
[01:29:32.723]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:32.723]             }
[01:29:32.723]             else {
[01:29:32.723]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:32.723]             }
[01:29:32.723]             {
[01:29:32.723]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:32.723]                   0L) {
[01:29:32.723]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:32.723]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:32.723]                   base::options(opts)
[01:29:32.723]                 }
[01:29:32.723]                 {
[01:29:32.723]                   {
[01:29:32.723]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:32.723]                     NULL
[01:29:32.723]                   }
[01:29:32.723]                   options(future.plan = NULL)
[01:29:32.723]                   if (is.na(NA_character_)) 
[01:29:32.723]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.723]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:32.723]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:32.723]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:32.723]                     envir = parent.frame()) 
[01:29:32.723]                   {
[01:29:32.723]                     if (is.function(workers)) 
[01:29:32.723]                       workers <- workers()
[01:29:32.723]                     workers <- structure(as.integer(workers), 
[01:29:32.723]                       class = class(workers))
[01:29:32.723]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:32.723]                       workers >= 1)
[01:29:32.723]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:32.723]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:32.723]                     }
[01:29:32.723]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:32.723]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:32.723]                       envir = envir)
[01:29:32.723]                     if (!future$lazy) 
[01:29:32.723]                       future <- run(future)
[01:29:32.723]                     invisible(future)
[01:29:32.723]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:32.723]                 }
[01:29:32.723]             }
[01:29:32.723]         }
[01:29:32.723]     })
[01:29:32.723]     if (TRUE) {
[01:29:32.723]         base::sink(type = "output", split = FALSE)
[01:29:32.723]         if (TRUE) {
[01:29:32.723]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:32.723]         }
[01:29:32.723]         else {
[01:29:32.723]             ...future.result["stdout"] <- base::list(NULL)
[01:29:32.723]         }
[01:29:32.723]         base::close(...future.stdout)
[01:29:32.723]         ...future.stdout <- NULL
[01:29:32.723]     }
[01:29:32.723]     ...future.result$conditions <- ...future.conditions
[01:29:32.723]     ...future.result$finished <- base::Sys.time()
[01:29:32.723]     ...future.result
[01:29:32.723] }
[01:29:32.728] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:32.753] receiveMessageFromWorker() for ClusterFuture ...
[01:29:32.753] - Validating connection of MultisessionFuture
[01:29:32.754] - received message: FutureResult
[01:29:32.754] - Received FutureResult
[01:29:32.754] - Erased future from FutureRegistry
[01:29:32.754] result() for ClusterFuture ...
[01:29:32.755] - result already collected: FutureResult
[01:29:32.755] result() for ClusterFuture ... done
[01:29:32.755] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:32.755] result() for ClusterFuture ...
[01:29:32.755] - result already collected: FutureResult
[01:29:32.755] result() for ClusterFuture ... done
[01:29:32.756] result() for ClusterFuture ...
[01:29:32.756] - result already collected: FutureResult
[01:29:32.756] result() for ClusterFuture ... done
[01:29:32.757] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:32.758] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:32.758] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:32.758] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:32.759] MultisessionFuture started
[01:29:32.759] - Launch lazy future ... done
[01:29:32.760] run() for 'MultisessionFuture' ... done
[01:29:32.760] getGlobalsAndPackages() ...
[01:29:32.761] Searching for globals...
[01:29:32.762] - globals found: [3] '{', 'sample', 'x'
[01:29:32.762] Searching for globals ... DONE
[01:29:32.763] Resolving globals: FALSE
[01:29:32.763] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:32.764] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:32.764] - globals: [1] 'x'
[01:29:32.764] 
[01:29:32.764] getGlobalsAndPackages() ... DONE
[01:29:32.765] run() for 'Future' ...
[01:29:32.765] - state: 'created'
[01:29:32.765] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:32.786] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:32.787] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:32.787]   - Field: 'node'
[01:29:32.787]   - Field: 'label'
[01:29:32.788]   - Field: 'local'
[01:29:32.788]   - Field: 'owner'
[01:29:32.788]   - Field: 'envir'
[01:29:32.789]   - Field: 'workers'
[01:29:32.789]   - Field: 'packages'
[01:29:32.789]   - Field: 'gc'
[01:29:32.790]   - Field: 'conditions'
[01:29:32.790]   - Field: 'persistent'
[01:29:32.790]   - Field: 'expr'
[01:29:32.791]   - Field: 'uuid'
[01:29:32.791]   - Field: 'seed'
[01:29:32.791]   - Field: 'version'
[01:29:32.791]   - Field: 'result'
[01:29:32.792]   - Field: 'asynchronous'
[01:29:32.792]   - Field: 'calls'
[01:29:32.792]   - Field: 'globals'
[01:29:32.793]   - Field: 'stdout'
[01:29:32.793]   - Field: 'earlySignal'
[01:29:32.793]   - Field: 'lazy'
[01:29:32.794]   - Field: 'state'
[01:29:32.794] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:32.794] - Launch lazy future ...
[01:29:32.795] Packages needed by the future expression (n = 0): <none>
[01:29:32.796] Packages needed by future strategies (n = 0): <none>
[01:29:32.797] {
[01:29:32.797]     {
[01:29:32.797]         {
[01:29:32.797]             ...future.startTime <- base::Sys.time()
[01:29:32.797]             {
[01:29:32.797]                 {
[01:29:32.797]                   {
[01:29:32.797]                     {
[01:29:32.797]                       base::local({
[01:29:32.797]                         has_future <- base::requireNamespace("future", 
[01:29:32.797]                           quietly = TRUE)
[01:29:32.797]                         if (has_future) {
[01:29:32.797]                           ns <- base::getNamespace("future")
[01:29:32.797]                           version <- ns[[".package"]][["version"]]
[01:29:32.797]                           if (is.null(version)) 
[01:29:32.797]                             version <- utils::packageVersion("future")
[01:29:32.797]                         }
[01:29:32.797]                         else {
[01:29:32.797]                           version <- NULL
[01:29:32.797]                         }
[01:29:32.797]                         if (!has_future || version < "1.8.0") {
[01:29:32.797]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:32.797]                             "", base::R.version$version.string), 
[01:29:32.797]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:32.797]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:32.797]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:32.797]                               "release", "version")], collapse = " "), 
[01:29:32.797]                             hostname = base::Sys.info()[["nodename"]])
[01:29:32.797]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:32.797]                             info)
[01:29:32.797]                           info <- base::paste(info, collapse = "; ")
[01:29:32.797]                           if (!has_future) {
[01:29:32.797]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:32.797]                               info)
[01:29:32.797]                           }
[01:29:32.797]                           else {
[01:29:32.797]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:32.797]                               info, version)
[01:29:32.797]                           }
[01:29:32.797]                           base::stop(msg)
[01:29:32.797]                         }
[01:29:32.797]                       })
[01:29:32.797]                     }
[01:29:32.797]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:32.797]                     base::options(mc.cores = 1L)
[01:29:32.797]                   }
[01:29:32.797]                   options(future.plan = NULL)
[01:29:32.797]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.797]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:32.797]                 }
[01:29:32.797]                 ...future.workdir <- getwd()
[01:29:32.797]             }
[01:29:32.797]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:32.797]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:32.797]         }
[01:29:32.797]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:32.797]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:32.797]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:32.797]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:32.797]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:32.797]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:32.797]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:32.797]             base::names(...future.oldOptions))
[01:29:32.797]     }
[01:29:32.797]     if (FALSE) {
[01:29:32.797]     }
[01:29:32.797]     else {
[01:29:32.797]         if (TRUE) {
[01:29:32.797]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:32.797]                 open = "w")
[01:29:32.797]         }
[01:29:32.797]         else {
[01:29:32.797]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:32.797]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:32.797]         }
[01:29:32.797]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:32.797]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:32.797]             base::sink(type = "output", split = FALSE)
[01:29:32.797]             base::close(...future.stdout)
[01:29:32.797]         }, add = TRUE)
[01:29:32.797]     }
[01:29:32.797]     ...future.frame <- base::sys.nframe()
[01:29:32.797]     ...future.conditions <- base::list()
[01:29:32.797]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:32.797]     if (FALSE) {
[01:29:32.797]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:32.797]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:32.797]     }
[01:29:32.797]     ...future.result <- base::tryCatch({
[01:29:32.797]         base::withCallingHandlers({
[01:29:32.797]             ...future.value <- base::withVisible(base::local({
[01:29:32.797]                 ...future.makeSendCondition <- base::local({
[01:29:32.797]                   sendCondition <- NULL
[01:29:32.797]                   function(frame = 1L) {
[01:29:32.797]                     if (is.function(sendCondition)) 
[01:29:32.797]                       return(sendCondition)
[01:29:32.797]                     ns <- getNamespace("parallel")
[01:29:32.797]                     if (exists("sendData", mode = "function", 
[01:29:32.797]                       envir = ns)) {
[01:29:32.797]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:32.797]                         envir = ns)
[01:29:32.797]                       envir <- sys.frame(frame)
[01:29:32.797]                       master <- NULL
[01:29:32.797]                       while (!identical(envir, .GlobalEnv) && 
[01:29:32.797]                         !identical(envir, emptyenv())) {
[01:29:32.797]                         if (exists("master", mode = "list", envir = envir, 
[01:29:32.797]                           inherits = FALSE)) {
[01:29:32.797]                           master <- get("master", mode = "list", 
[01:29:32.797]                             envir = envir, inherits = FALSE)
[01:29:32.797]                           if (inherits(master, c("SOCKnode", 
[01:29:32.797]                             "SOCK0node"))) {
[01:29:32.797]                             sendCondition <<- function(cond) {
[01:29:32.797]                               data <- list(type = "VALUE", value = cond, 
[01:29:32.797]                                 success = TRUE)
[01:29:32.797]                               parallel_sendData(master, data)
[01:29:32.797]                             }
[01:29:32.797]                             return(sendCondition)
[01:29:32.797]                           }
[01:29:32.797]                         }
[01:29:32.797]                         frame <- frame + 1L
[01:29:32.797]                         envir <- sys.frame(frame)
[01:29:32.797]                       }
[01:29:32.797]                     }
[01:29:32.797]                     sendCondition <<- function(cond) NULL
[01:29:32.797]                   }
[01:29:32.797]                 })
[01:29:32.797]                 withCallingHandlers({
[01:29:32.797]                   {
[01:29:32.797]                     sample(x, size = 1L)
[01:29:32.797]                   }
[01:29:32.797]                 }, immediateCondition = function(cond) {
[01:29:32.797]                   sendCondition <- ...future.makeSendCondition()
[01:29:32.797]                   sendCondition(cond)
[01:29:32.797]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.797]                   {
[01:29:32.797]                     inherits <- base::inherits
[01:29:32.797]                     invokeRestart <- base::invokeRestart
[01:29:32.797]                     is.null <- base::is.null
[01:29:32.797]                     muffled <- FALSE
[01:29:32.797]                     if (inherits(cond, "message")) {
[01:29:32.797]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:32.797]                       if (muffled) 
[01:29:32.797]                         invokeRestart("muffleMessage")
[01:29:32.797]                     }
[01:29:32.797]                     else if (inherits(cond, "warning")) {
[01:29:32.797]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:32.797]                       if (muffled) 
[01:29:32.797]                         invokeRestart("muffleWarning")
[01:29:32.797]                     }
[01:29:32.797]                     else if (inherits(cond, "condition")) {
[01:29:32.797]                       if (!is.null(pattern)) {
[01:29:32.797]                         computeRestarts <- base::computeRestarts
[01:29:32.797]                         grepl <- base::grepl
[01:29:32.797]                         restarts <- computeRestarts(cond)
[01:29:32.797]                         for (restart in restarts) {
[01:29:32.797]                           name <- restart$name
[01:29:32.797]                           if (is.null(name)) 
[01:29:32.797]                             next
[01:29:32.797]                           if (!grepl(pattern, name)) 
[01:29:32.797]                             next
[01:29:32.797]                           invokeRestart(restart)
[01:29:32.797]                           muffled <- TRUE
[01:29:32.797]                           break
[01:29:32.797]                         }
[01:29:32.797]                       }
[01:29:32.797]                     }
[01:29:32.797]                     invisible(muffled)
[01:29:32.797]                   }
[01:29:32.797]                   muffleCondition(cond)
[01:29:32.797]                 })
[01:29:32.797]             }))
[01:29:32.797]             future::FutureResult(value = ...future.value$value, 
[01:29:32.797]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.797]                   ...future.rng), globalenv = if (FALSE) 
[01:29:32.797]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:32.797]                     ...future.globalenv.names))
[01:29:32.797]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:32.797]         }, condition = base::local({
[01:29:32.797]             c <- base::c
[01:29:32.797]             inherits <- base::inherits
[01:29:32.797]             invokeRestart <- base::invokeRestart
[01:29:32.797]             length <- base::length
[01:29:32.797]             list <- base::list
[01:29:32.797]             seq.int <- base::seq.int
[01:29:32.797]             signalCondition <- base::signalCondition
[01:29:32.797]             sys.calls <- base::sys.calls
[01:29:32.797]             `[[` <- base::`[[`
[01:29:32.797]             `+` <- base::`+`
[01:29:32.797]             `<<-` <- base::`<<-`
[01:29:32.797]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:32.797]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:32.797]                   3L)]
[01:29:32.797]             }
[01:29:32.797]             function(cond) {
[01:29:32.797]                 is_error <- inherits(cond, "error")
[01:29:32.797]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:32.797]                   NULL)
[01:29:32.797]                 if (is_error) {
[01:29:32.797]                   sessionInformation <- function() {
[01:29:32.797]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:32.797]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:32.797]                       search = base::search(), system = base::Sys.info())
[01:29:32.797]                   }
[01:29:32.797]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.797]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:32.797]                     cond$call), session = sessionInformation(), 
[01:29:32.797]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:32.797]                   signalCondition(cond)
[01:29:32.797]                 }
[01:29:32.797]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:32.797]                 "immediateCondition"))) {
[01:29:32.797]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:32.797]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.797]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:32.797]                   if (TRUE && !signal) {
[01:29:32.797]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.797]                     {
[01:29:32.797]                       inherits <- base::inherits
[01:29:32.797]                       invokeRestart <- base::invokeRestart
[01:29:32.797]                       is.null <- base::is.null
[01:29:32.797]                       muffled <- FALSE
[01:29:32.797]                       if (inherits(cond, "message")) {
[01:29:32.797]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.797]                         if (muffled) 
[01:29:32.797]                           invokeRestart("muffleMessage")
[01:29:32.797]                       }
[01:29:32.797]                       else if (inherits(cond, "warning")) {
[01:29:32.797]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.797]                         if (muffled) 
[01:29:32.797]                           invokeRestart("muffleWarning")
[01:29:32.797]                       }
[01:29:32.797]                       else if (inherits(cond, "condition")) {
[01:29:32.797]                         if (!is.null(pattern)) {
[01:29:32.797]                           computeRestarts <- base::computeRestarts
[01:29:32.797]                           grepl <- base::grepl
[01:29:32.797]                           restarts <- computeRestarts(cond)
[01:29:32.797]                           for (restart in restarts) {
[01:29:32.797]                             name <- restart$name
[01:29:32.797]                             if (is.null(name)) 
[01:29:32.797]                               next
[01:29:32.797]                             if (!grepl(pattern, name)) 
[01:29:32.797]                               next
[01:29:32.797]                             invokeRestart(restart)
[01:29:32.797]                             muffled <- TRUE
[01:29:32.797]                             break
[01:29:32.797]                           }
[01:29:32.797]                         }
[01:29:32.797]                       }
[01:29:32.797]                       invisible(muffled)
[01:29:32.797]                     }
[01:29:32.797]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.797]                   }
[01:29:32.797]                 }
[01:29:32.797]                 else {
[01:29:32.797]                   if (TRUE) {
[01:29:32.797]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.797]                     {
[01:29:32.797]                       inherits <- base::inherits
[01:29:32.797]                       invokeRestart <- base::invokeRestart
[01:29:32.797]                       is.null <- base::is.null
[01:29:32.797]                       muffled <- FALSE
[01:29:32.797]                       if (inherits(cond, "message")) {
[01:29:32.797]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.797]                         if (muffled) 
[01:29:32.797]                           invokeRestart("muffleMessage")
[01:29:32.797]                       }
[01:29:32.797]                       else if (inherits(cond, "warning")) {
[01:29:32.797]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.797]                         if (muffled) 
[01:29:32.797]                           invokeRestart("muffleWarning")
[01:29:32.797]                       }
[01:29:32.797]                       else if (inherits(cond, "condition")) {
[01:29:32.797]                         if (!is.null(pattern)) {
[01:29:32.797]                           computeRestarts <- base::computeRestarts
[01:29:32.797]                           grepl <- base::grepl
[01:29:32.797]                           restarts <- computeRestarts(cond)
[01:29:32.797]                           for (restart in restarts) {
[01:29:32.797]                             name <- restart$name
[01:29:32.797]                             if (is.null(name)) 
[01:29:32.797]                               next
[01:29:32.797]                             if (!grepl(pattern, name)) 
[01:29:32.797]                               next
[01:29:32.797]                             invokeRestart(restart)
[01:29:32.797]                             muffled <- TRUE
[01:29:32.797]                             break
[01:29:32.797]                           }
[01:29:32.797]                         }
[01:29:32.797]                       }
[01:29:32.797]                       invisible(muffled)
[01:29:32.797]                     }
[01:29:32.797]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.797]                   }
[01:29:32.797]                 }
[01:29:32.797]             }
[01:29:32.797]         }))
[01:29:32.797]     }, error = function(ex) {
[01:29:32.797]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:32.797]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.797]                 ...future.rng), started = ...future.startTime, 
[01:29:32.797]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:32.797]             version = "1.8"), class = "FutureResult")
[01:29:32.797]     }, finally = {
[01:29:32.797]         if (!identical(...future.workdir, getwd())) 
[01:29:32.797]             setwd(...future.workdir)
[01:29:32.797]         {
[01:29:32.797]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:32.797]                 ...future.oldOptions$nwarnings <- NULL
[01:29:32.797]             }
[01:29:32.797]             base::options(...future.oldOptions)
[01:29:32.797]             if (.Platform$OS.type == "windows") {
[01:29:32.797]                 old_names <- names(...future.oldEnvVars)
[01:29:32.797]                 envs <- base::Sys.getenv()
[01:29:32.797]                 names <- names(envs)
[01:29:32.797]                 common <- intersect(names, old_names)
[01:29:32.797]                 added <- setdiff(names, old_names)
[01:29:32.797]                 removed <- setdiff(old_names, names)
[01:29:32.797]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:32.797]                   envs[common]]
[01:29:32.797]                 NAMES <- toupper(changed)
[01:29:32.797]                 args <- list()
[01:29:32.797]                 for (kk in seq_along(NAMES)) {
[01:29:32.797]                   name <- changed[[kk]]
[01:29:32.797]                   NAME <- NAMES[[kk]]
[01:29:32.797]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.797]                     next
[01:29:32.797]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.797]                 }
[01:29:32.797]                 NAMES <- toupper(added)
[01:29:32.797]                 for (kk in seq_along(NAMES)) {
[01:29:32.797]                   name <- added[[kk]]
[01:29:32.797]                   NAME <- NAMES[[kk]]
[01:29:32.797]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.797]                     next
[01:29:32.797]                   args[[name]] <- ""
[01:29:32.797]                 }
[01:29:32.797]                 NAMES <- toupper(removed)
[01:29:32.797]                 for (kk in seq_along(NAMES)) {
[01:29:32.797]                   name <- removed[[kk]]
[01:29:32.797]                   NAME <- NAMES[[kk]]
[01:29:32.797]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.797]                     next
[01:29:32.797]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.797]                 }
[01:29:32.797]                 if (length(args) > 0) 
[01:29:32.797]                   base::do.call(base::Sys.setenv, args = args)
[01:29:32.797]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:32.797]             }
[01:29:32.797]             else {
[01:29:32.797]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:32.797]             }
[01:29:32.797]             {
[01:29:32.797]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:32.797]                   0L) {
[01:29:32.797]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:32.797]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:32.797]                   base::options(opts)
[01:29:32.797]                 }
[01:29:32.797]                 {
[01:29:32.797]                   {
[01:29:32.797]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:32.797]                     NULL
[01:29:32.797]                   }
[01:29:32.797]                   options(future.plan = NULL)
[01:29:32.797]                   if (is.na(NA_character_)) 
[01:29:32.797]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.797]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:32.797]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:32.797]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:32.797]                     envir = parent.frame()) 
[01:29:32.797]                   {
[01:29:32.797]                     if (is.function(workers)) 
[01:29:32.797]                       workers <- workers()
[01:29:32.797]                     workers <- structure(as.integer(workers), 
[01:29:32.797]                       class = class(workers))
[01:29:32.797]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:32.797]                       workers >= 1)
[01:29:32.797]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:32.797]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:32.797]                     }
[01:29:32.797]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:32.797]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:32.797]                       envir = envir)
[01:29:32.797]                     if (!future$lazy) 
[01:29:32.797]                       future <- run(future)
[01:29:32.797]                     invisible(future)
[01:29:32.797]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:32.797]                 }
[01:29:32.797]             }
[01:29:32.797]         }
[01:29:32.797]     })
[01:29:32.797]     if (TRUE) {
[01:29:32.797]         base::sink(type = "output", split = FALSE)
[01:29:32.797]         if (TRUE) {
[01:29:32.797]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:32.797]         }
[01:29:32.797]         else {
[01:29:32.797]             ...future.result["stdout"] <- base::list(NULL)
[01:29:32.797]         }
[01:29:32.797]         base::close(...future.stdout)
[01:29:32.797]         ...future.stdout <- NULL
[01:29:32.797]     }
[01:29:32.797]     ...future.result$conditions <- ...future.conditions
[01:29:32.797]     ...future.result$finished <- base::Sys.time()
[01:29:32.797]     ...future.result
[01:29:32.797] }
[01:29:32.805] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:32.831] receiveMessageFromWorker() for ClusterFuture ...
[01:29:32.831] - Validating connection of MultisessionFuture
[01:29:32.831] - received message: FutureResult
[01:29:32.832] - Received FutureResult
[01:29:32.832] - Erased future from FutureRegistry
[01:29:32.832] result() for ClusterFuture ...
[01:29:32.832] - result already collected: FutureResult
[01:29:32.832] result() for ClusterFuture ... done
[01:29:32.833] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:32.833] result() for ClusterFuture ...
[01:29:32.833] - result already collected: FutureResult
[01:29:32.833] result() for ClusterFuture ... done
[01:29:32.833] result() for ClusterFuture ...
[01:29:32.834] - result already collected: FutureResult
[01:29:32.834] result() for ClusterFuture ... done
[01:29:32.835] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:32.835] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:32.836] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:32.836] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:32.837] MultisessionFuture started
[01:29:32.837] - Launch lazy future ... done
[01:29:32.837] run() for 'MultisessionFuture' ... done
[01:29:32.838] getGlobalsAndPackages() ...
[01:29:32.838] Searching for globals...
[01:29:32.840] - globals found: [3] '{', 'sample', 'x'
[01:29:32.840] Searching for globals ... DONE
[01:29:32.840] Resolving globals: FALSE
[01:29:32.841] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:32.841] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:32.841] - globals: [1] 'x'
[01:29:32.842] 
[01:29:32.842] getGlobalsAndPackages() ... DONE
[01:29:32.842] run() for 'Future' ...
[01:29:32.842] - state: 'created'
[01:29:32.843] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:32.858] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:32.858] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:32.858]   - Field: 'node'
[01:29:32.859]   - Field: 'label'
[01:29:32.859]   - Field: 'local'
[01:29:32.859]   - Field: 'owner'
[01:29:32.859]   - Field: 'envir'
[01:29:32.859]   - Field: 'workers'
[01:29:32.860]   - Field: 'packages'
[01:29:32.860]   - Field: 'gc'
[01:29:32.860]   - Field: 'conditions'
[01:29:32.860]   - Field: 'persistent'
[01:29:32.860]   - Field: 'expr'
[01:29:32.860]   - Field: 'uuid'
[01:29:32.861]   - Field: 'seed'
[01:29:32.861]   - Field: 'version'
[01:29:32.861]   - Field: 'result'
[01:29:32.861]   - Field: 'asynchronous'
[01:29:32.861]   - Field: 'calls'
[01:29:32.862]   - Field: 'globals'
[01:29:32.862]   - Field: 'stdout'
[01:29:32.862]   - Field: 'earlySignal'
[01:29:32.862]   - Field: 'lazy'
[01:29:32.862]   - Field: 'state'
[01:29:32.863] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:32.863] - Launch lazy future ...
[01:29:32.863] Packages needed by the future expression (n = 0): <none>
[01:29:32.863] Packages needed by future strategies (n = 0): <none>
[01:29:32.864] {
[01:29:32.864]     {
[01:29:32.864]         {
[01:29:32.864]             ...future.startTime <- base::Sys.time()
[01:29:32.864]             {
[01:29:32.864]                 {
[01:29:32.864]                   {
[01:29:32.864]                     {
[01:29:32.864]                       base::local({
[01:29:32.864]                         has_future <- base::requireNamespace("future", 
[01:29:32.864]                           quietly = TRUE)
[01:29:32.864]                         if (has_future) {
[01:29:32.864]                           ns <- base::getNamespace("future")
[01:29:32.864]                           version <- ns[[".package"]][["version"]]
[01:29:32.864]                           if (is.null(version)) 
[01:29:32.864]                             version <- utils::packageVersion("future")
[01:29:32.864]                         }
[01:29:32.864]                         else {
[01:29:32.864]                           version <- NULL
[01:29:32.864]                         }
[01:29:32.864]                         if (!has_future || version < "1.8.0") {
[01:29:32.864]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:32.864]                             "", base::R.version$version.string), 
[01:29:32.864]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:32.864]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:32.864]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:32.864]                               "release", "version")], collapse = " "), 
[01:29:32.864]                             hostname = base::Sys.info()[["nodename"]])
[01:29:32.864]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:32.864]                             info)
[01:29:32.864]                           info <- base::paste(info, collapse = "; ")
[01:29:32.864]                           if (!has_future) {
[01:29:32.864]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:32.864]                               info)
[01:29:32.864]                           }
[01:29:32.864]                           else {
[01:29:32.864]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:32.864]                               info, version)
[01:29:32.864]                           }
[01:29:32.864]                           base::stop(msg)
[01:29:32.864]                         }
[01:29:32.864]                       })
[01:29:32.864]                     }
[01:29:32.864]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:32.864]                     base::options(mc.cores = 1L)
[01:29:32.864]                   }
[01:29:32.864]                   options(future.plan = NULL)
[01:29:32.864]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.864]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:32.864]                 }
[01:29:32.864]                 ...future.workdir <- getwd()
[01:29:32.864]             }
[01:29:32.864]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:32.864]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:32.864]         }
[01:29:32.864]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:32.864]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:32.864]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:32.864]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:32.864]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[01:29:32.864]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:32.864]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:32.864]             base::names(...future.oldOptions))
[01:29:32.864]     }
[01:29:32.864]     if (FALSE) {
[01:29:32.864]     }
[01:29:32.864]     else {
[01:29:32.864]         if (TRUE) {
[01:29:32.864]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:32.864]                 open = "w")
[01:29:32.864]         }
[01:29:32.864]         else {
[01:29:32.864]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:32.864]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:32.864]         }
[01:29:32.864]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:32.864]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:32.864]             base::sink(type = "output", split = FALSE)
[01:29:32.864]             base::close(...future.stdout)
[01:29:32.864]         }, add = TRUE)
[01:29:32.864]     }
[01:29:32.864]     ...future.frame <- base::sys.nframe()
[01:29:32.864]     ...future.conditions <- base::list()
[01:29:32.864]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:32.864]     if (FALSE) {
[01:29:32.864]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:32.864]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:32.864]     }
[01:29:32.864]     ...future.result <- base::tryCatch({
[01:29:32.864]         base::withCallingHandlers({
[01:29:32.864]             ...future.value <- base::withVisible(base::local({
[01:29:32.864]                 ...future.makeSendCondition <- base::local({
[01:29:32.864]                   sendCondition <- NULL
[01:29:32.864]                   function(frame = 1L) {
[01:29:32.864]                     if (is.function(sendCondition)) 
[01:29:32.864]                       return(sendCondition)
[01:29:32.864]                     ns <- getNamespace("parallel")
[01:29:32.864]                     if (exists("sendData", mode = "function", 
[01:29:32.864]                       envir = ns)) {
[01:29:32.864]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:32.864]                         envir = ns)
[01:29:32.864]                       envir <- sys.frame(frame)
[01:29:32.864]                       master <- NULL
[01:29:32.864]                       while (!identical(envir, .GlobalEnv) && 
[01:29:32.864]                         !identical(envir, emptyenv())) {
[01:29:32.864]                         if (exists("master", mode = "list", envir = envir, 
[01:29:32.864]                           inherits = FALSE)) {
[01:29:32.864]                           master <- get("master", mode = "list", 
[01:29:32.864]                             envir = envir, inherits = FALSE)
[01:29:32.864]                           if (inherits(master, c("SOCKnode", 
[01:29:32.864]                             "SOCK0node"))) {
[01:29:32.864]                             sendCondition <<- function(cond) {
[01:29:32.864]                               data <- list(type = "VALUE", value = cond, 
[01:29:32.864]                                 success = TRUE)
[01:29:32.864]                               parallel_sendData(master, data)
[01:29:32.864]                             }
[01:29:32.864]                             return(sendCondition)
[01:29:32.864]                           }
[01:29:32.864]                         }
[01:29:32.864]                         frame <- frame + 1L
[01:29:32.864]                         envir <- sys.frame(frame)
[01:29:32.864]                       }
[01:29:32.864]                     }
[01:29:32.864]                     sendCondition <<- function(cond) NULL
[01:29:32.864]                   }
[01:29:32.864]                 })
[01:29:32.864]                 withCallingHandlers({
[01:29:32.864]                   {
[01:29:32.864]                     sample(x, size = 1L)
[01:29:32.864]                   }
[01:29:32.864]                 }, immediateCondition = function(cond) {
[01:29:32.864]                   sendCondition <- ...future.makeSendCondition()
[01:29:32.864]                   sendCondition(cond)
[01:29:32.864]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.864]                   {
[01:29:32.864]                     inherits <- base::inherits
[01:29:32.864]                     invokeRestart <- base::invokeRestart
[01:29:32.864]                     is.null <- base::is.null
[01:29:32.864]                     muffled <- FALSE
[01:29:32.864]                     if (inherits(cond, "message")) {
[01:29:32.864]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:32.864]                       if (muffled) 
[01:29:32.864]                         invokeRestart("muffleMessage")
[01:29:32.864]                     }
[01:29:32.864]                     else if (inherits(cond, "warning")) {
[01:29:32.864]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:32.864]                       if (muffled) 
[01:29:32.864]                         invokeRestart("muffleWarning")
[01:29:32.864]                     }
[01:29:32.864]                     else if (inherits(cond, "condition")) {
[01:29:32.864]                       if (!is.null(pattern)) {
[01:29:32.864]                         computeRestarts <- base::computeRestarts
[01:29:32.864]                         grepl <- base::grepl
[01:29:32.864]                         restarts <- computeRestarts(cond)
[01:29:32.864]                         for (restart in restarts) {
[01:29:32.864]                           name <- restart$name
[01:29:32.864]                           if (is.null(name)) 
[01:29:32.864]                             next
[01:29:32.864]                           if (!grepl(pattern, name)) 
[01:29:32.864]                             next
[01:29:32.864]                           invokeRestart(restart)
[01:29:32.864]                           muffled <- TRUE
[01:29:32.864]                           break
[01:29:32.864]                         }
[01:29:32.864]                       }
[01:29:32.864]                     }
[01:29:32.864]                     invisible(muffled)
[01:29:32.864]                   }
[01:29:32.864]                   muffleCondition(cond)
[01:29:32.864]                 })
[01:29:32.864]             }))
[01:29:32.864]             future::FutureResult(value = ...future.value$value, 
[01:29:32.864]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.864]                   ...future.rng), globalenv = if (FALSE) 
[01:29:32.864]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:32.864]                     ...future.globalenv.names))
[01:29:32.864]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:32.864]         }, condition = base::local({
[01:29:32.864]             c <- base::c
[01:29:32.864]             inherits <- base::inherits
[01:29:32.864]             invokeRestart <- base::invokeRestart
[01:29:32.864]             length <- base::length
[01:29:32.864]             list <- base::list
[01:29:32.864]             seq.int <- base::seq.int
[01:29:32.864]             signalCondition <- base::signalCondition
[01:29:32.864]             sys.calls <- base::sys.calls
[01:29:32.864]             `[[` <- base::`[[`
[01:29:32.864]             `+` <- base::`+`
[01:29:32.864]             `<<-` <- base::`<<-`
[01:29:32.864]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:32.864]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:32.864]                   3L)]
[01:29:32.864]             }
[01:29:32.864]             function(cond) {
[01:29:32.864]                 is_error <- inherits(cond, "error")
[01:29:32.864]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:32.864]                   NULL)
[01:29:32.864]                 if (is_error) {
[01:29:32.864]                   sessionInformation <- function() {
[01:29:32.864]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:32.864]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:32.864]                       search = base::search(), system = base::Sys.info())
[01:29:32.864]                   }
[01:29:32.864]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.864]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:32.864]                     cond$call), session = sessionInformation(), 
[01:29:32.864]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:32.864]                   signalCondition(cond)
[01:29:32.864]                 }
[01:29:32.864]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:32.864]                 "immediateCondition"))) {
[01:29:32.864]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:32.864]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.864]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:32.864]                   if (TRUE && !signal) {
[01:29:32.864]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.864]                     {
[01:29:32.864]                       inherits <- base::inherits
[01:29:32.864]                       invokeRestart <- base::invokeRestart
[01:29:32.864]                       is.null <- base::is.null
[01:29:32.864]                       muffled <- FALSE
[01:29:32.864]                       if (inherits(cond, "message")) {
[01:29:32.864]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.864]                         if (muffled) 
[01:29:32.864]                           invokeRestart("muffleMessage")
[01:29:32.864]                       }
[01:29:32.864]                       else if (inherits(cond, "warning")) {
[01:29:32.864]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.864]                         if (muffled) 
[01:29:32.864]                           invokeRestart("muffleWarning")
[01:29:32.864]                       }
[01:29:32.864]                       else if (inherits(cond, "condition")) {
[01:29:32.864]                         if (!is.null(pattern)) {
[01:29:32.864]                           computeRestarts <- base::computeRestarts
[01:29:32.864]                           grepl <- base::grepl
[01:29:32.864]                           restarts <- computeRestarts(cond)
[01:29:32.864]                           for (restart in restarts) {
[01:29:32.864]                             name <- restart$name
[01:29:32.864]                             if (is.null(name)) 
[01:29:32.864]                               next
[01:29:32.864]                             if (!grepl(pattern, name)) 
[01:29:32.864]                               next
[01:29:32.864]                             invokeRestart(restart)
[01:29:32.864]                             muffled <- TRUE
[01:29:32.864]                             break
[01:29:32.864]                           }
[01:29:32.864]                         }
[01:29:32.864]                       }
[01:29:32.864]                       invisible(muffled)
[01:29:32.864]                     }
[01:29:32.864]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.864]                   }
[01:29:32.864]                 }
[01:29:32.864]                 else {
[01:29:32.864]                   if (TRUE) {
[01:29:32.864]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.864]                     {
[01:29:32.864]                       inherits <- base::inherits
[01:29:32.864]                       invokeRestart <- base::invokeRestart
[01:29:32.864]                       is.null <- base::is.null
[01:29:32.864]                       muffled <- FALSE
[01:29:32.864]                       if (inherits(cond, "message")) {
[01:29:32.864]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.864]                         if (muffled) 
[01:29:32.864]                           invokeRestart("muffleMessage")
[01:29:32.864]                       }
[01:29:32.864]                       else if (inherits(cond, "warning")) {
[01:29:32.864]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.864]                         if (muffled) 
[01:29:32.864]                           invokeRestart("muffleWarning")
[01:29:32.864]                       }
[01:29:32.864]                       else if (inherits(cond, "condition")) {
[01:29:32.864]                         if (!is.null(pattern)) {
[01:29:32.864]                           computeRestarts <- base::computeRestarts
[01:29:32.864]                           grepl <- base::grepl
[01:29:32.864]                           restarts <- computeRestarts(cond)
[01:29:32.864]                           for (restart in restarts) {
[01:29:32.864]                             name <- restart$name
[01:29:32.864]                             if (is.null(name)) 
[01:29:32.864]                               next
[01:29:32.864]                             if (!grepl(pattern, name)) 
[01:29:32.864]                               next
[01:29:32.864]                             invokeRestart(restart)
[01:29:32.864]                             muffled <- TRUE
[01:29:32.864]                             break
[01:29:32.864]                           }
[01:29:32.864]                         }
[01:29:32.864]                       }
[01:29:32.864]                       invisible(muffled)
[01:29:32.864]                     }
[01:29:32.864]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.864]                   }
[01:29:32.864]                 }
[01:29:32.864]             }
[01:29:32.864]         }))
[01:29:32.864]     }, error = function(ex) {
[01:29:32.864]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:32.864]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.864]                 ...future.rng), started = ...future.startTime, 
[01:29:32.864]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:32.864]             version = "1.8"), class = "FutureResult")
[01:29:32.864]     }, finally = {
[01:29:32.864]         if (!identical(...future.workdir, getwd())) 
[01:29:32.864]             setwd(...future.workdir)
[01:29:32.864]         {
[01:29:32.864]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:32.864]                 ...future.oldOptions$nwarnings <- NULL
[01:29:32.864]             }
[01:29:32.864]             base::options(...future.oldOptions)
[01:29:32.864]             if (.Platform$OS.type == "windows") {
[01:29:32.864]                 old_names <- names(...future.oldEnvVars)
[01:29:32.864]                 envs <- base::Sys.getenv()
[01:29:32.864]                 names <- names(envs)
[01:29:32.864]                 common <- intersect(names, old_names)
[01:29:32.864]                 added <- setdiff(names, old_names)
[01:29:32.864]                 removed <- setdiff(old_names, names)
[01:29:32.864]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:32.864]                   envs[common]]
[01:29:32.864]                 NAMES <- toupper(changed)
[01:29:32.864]                 args <- list()
[01:29:32.864]                 for (kk in seq_along(NAMES)) {
[01:29:32.864]                   name <- changed[[kk]]
[01:29:32.864]                   NAME <- NAMES[[kk]]
[01:29:32.864]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.864]                     next
[01:29:32.864]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.864]                 }
[01:29:32.864]                 NAMES <- toupper(added)
[01:29:32.864]                 for (kk in seq_along(NAMES)) {
[01:29:32.864]                   name <- added[[kk]]
[01:29:32.864]                   NAME <- NAMES[[kk]]
[01:29:32.864]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.864]                     next
[01:29:32.864]                   args[[name]] <- ""
[01:29:32.864]                 }
[01:29:32.864]                 NAMES <- toupper(removed)
[01:29:32.864]                 for (kk in seq_along(NAMES)) {
[01:29:32.864]                   name <- removed[[kk]]
[01:29:32.864]                   NAME <- NAMES[[kk]]
[01:29:32.864]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.864]                     next
[01:29:32.864]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.864]                 }
[01:29:32.864]                 if (length(args) > 0) 
[01:29:32.864]                   base::do.call(base::Sys.setenv, args = args)
[01:29:32.864]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:32.864]             }
[01:29:32.864]             else {
[01:29:32.864]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:32.864]             }
[01:29:32.864]             {
[01:29:32.864]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:32.864]                   0L) {
[01:29:32.864]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:32.864]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:32.864]                   base::options(opts)
[01:29:32.864]                 }
[01:29:32.864]                 {
[01:29:32.864]                   {
[01:29:32.864]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:32.864]                     NULL
[01:29:32.864]                   }
[01:29:32.864]                   options(future.plan = NULL)
[01:29:32.864]                   if (is.na(NA_character_)) 
[01:29:32.864]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.864]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:32.864]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:32.864]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:32.864]                     envir = parent.frame()) 
[01:29:32.864]                   {
[01:29:32.864]                     if (is.function(workers)) 
[01:29:32.864]                       workers <- workers()
[01:29:32.864]                     workers <- structure(as.integer(workers), 
[01:29:32.864]                       class = class(workers))
[01:29:32.864]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:32.864]                       workers >= 1)
[01:29:32.864]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:32.864]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:32.864]                     }
[01:29:32.864]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:32.864]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:32.864]                       envir = envir)
[01:29:32.864]                     if (!future$lazy) 
[01:29:32.864]                       future <- run(future)
[01:29:32.864]                     invisible(future)
[01:29:32.864]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:32.864]                 }
[01:29:32.864]             }
[01:29:32.864]         }
[01:29:32.864]     })
[01:29:32.864]     if (TRUE) {
[01:29:32.864]         base::sink(type = "output", split = FALSE)
[01:29:32.864]         if (TRUE) {
[01:29:32.864]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:32.864]         }
[01:29:32.864]         else {
[01:29:32.864]             ...future.result["stdout"] <- base::list(NULL)
[01:29:32.864]         }
[01:29:32.864]         base::close(...future.stdout)
[01:29:32.864]         ...future.stdout <- NULL
[01:29:32.864]     }
[01:29:32.864]     ...future.result$conditions <- ...future.conditions
[01:29:32.864]     ...future.result$finished <- base::Sys.time()
[01:29:32.864]     ...future.result
[01:29:32.864] }
[01:29:32.869] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:32.893] receiveMessageFromWorker() for ClusterFuture ...
[01:29:32.894] - Validating connection of MultisessionFuture
[01:29:32.894] - received message: FutureResult
[01:29:32.894] - Received FutureResult
[01:29:32.894] - Erased future from FutureRegistry
[01:29:32.895] result() for ClusterFuture ...
[01:29:32.895] - result already collected: FutureResult
[01:29:32.895] result() for ClusterFuture ... done
[01:29:32.895] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:32.895] result() for ClusterFuture ...
[01:29:32.896] - result already collected: FutureResult
[01:29:32.896] result() for ClusterFuture ... done
[01:29:32.896] result() for ClusterFuture ...
[01:29:32.896] - result already collected: FutureResult
[01:29:32.896] result() for ClusterFuture ... done
[01:29:32.897] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:32.898] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:32.898] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:32.898] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:32.899] MultisessionFuture started
[01:29:32.899] - Launch lazy future ... done
[01:29:32.899] run() for 'MultisessionFuture' ... done
[01:29:32.900] result() for ClusterFuture ...
[01:29:32.900] - result already collected: FutureResult
[01:29:32.900] result() for ClusterFuture ... done
[01:29:32.900] result() for ClusterFuture ...
[01:29:32.901] - result already collected: FutureResult
[01:29:32.901] result() for ClusterFuture ... done
[01:29:32.901] result() for ClusterFuture ...
[01:29:32.901] - result already collected: FutureResult
[01:29:32.901] result() for ClusterFuture ... done
[01:29:32.902] result() for ClusterFuture ...
[01:29:32.902] - result already collected: FutureResult
[01:29:32.902] result() for ClusterFuture ... done
[01:29:32.902] result() for ClusterFuture ...
[01:29:32.903] receiveMessageFromWorker() for ClusterFuture ...
[01:29:32.903] - Validating connection of MultisessionFuture
[01:29:32.903] - received message: FutureResult
[01:29:32.903] - Received FutureResult
[01:29:32.903] - Erased future from FutureRegistry
[01:29:32.904] result() for ClusterFuture ...
[01:29:32.904] - result already collected: FutureResult
[01:29:32.904] result() for ClusterFuture ... done
[01:29:32.904] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:32.904] result() for ClusterFuture ... done
[01:29:32.905] result() for ClusterFuture ...
[01:29:32.905] - result already collected: FutureResult
[01:29:32.905] result() for ClusterFuture ... done
[01:29:32.905] result() for ClusterFuture ...
[01:29:32.905] receiveMessageFromWorker() for ClusterFuture ...
[01:29:32.906] - Validating connection of MultisessionFuture
[01:29:32.923] - received message: FutureResult
[01:29:32.923] - Received FutureResult
[01:29:32.923] - Erased future from FutureRegistry
[01:29:32.924] result() for ClusterFuture ...
[01:29:32.924] - result already collected: FutureResult
[01:29:32.924] result() for ClusterFuture ... done
[01:29:32.924] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:32.925] result() for ClusterFuture ... done
[01:29:32.925] result() for ClusterFuture ...
[01:29:32.925] - result already collected: FutureResult
[01:29:32.925] result() for ClusterFuture ... done
[[1]]
[1] 0

[[2]]
[1] 3

[[3]]
[1] 3

[[4]]
[1] 0

[01:29:32.927] getGlobalsAndPackages() ...
[01:29:32.927] Searching for globals...
[01:29:32.937] - globals found: [3] '{', 'sample', 'x'
[01:29:32.938] Searching for globals ... DONE
[01:29:32.938] Resolving globals: FALSE
[01:29:32.939] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:32.939] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:32.940] - globals: [1] 'x'
[01:29:32.940] 
[01:29:32.940] getGlobalsAndPackages() ... DONE
[01:29:32.941] run() for 'Future' ...
[01:29:32.941] - state: 'created'
[01:29:32.941] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:32.957] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:32.958] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:32.958]   - Field: 'node'
[01:29:32.958]   - Field: 'label'
[01:29:32.958]   - Field: 'local'
[01:29:32.958]   - Field: 'owner'
[01:29:32.959]   - Field: 'envir'
[01:29:32.959]   - Field: 'workers'
[01:29:32.959]   - Field: 'packages'
[01:29:32.959]   - Field: 'gc'
[01:29:32.959]   - Field: 'conditions'
[01:29:32.960]   - Field: 'persistent'
[01:29:32.960]   - Field: 'expr'
[01:29:32.960]   - Field: 'uuid'
[01:29:32.960]   - Field: 'seed'
[01:29:32.960]   - Field: 'version'
[01:29:32.960]   - Field: 'result'
[01:29:32.961]   - Field: 'asynchronous'
[01:29:32.961]   - Field: 'calls'
[01:29:32.961]   - Field: 'globals'
[01:29:32.961]   - Field: 'stdout'
[01:29:32.961]   - Field: 'earlySignal'
[01:29:32.962]   - Field: 'lazy'
[01:29:32.962]   - Field: 'state'
[01:29:32.962] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:32.962] - Launch lazy future ...
[01:29:32.963] Packages needed by the future expression (n = 0): <none>
[01:29:32.963] Packages needed by future strategies (n = 0): <none>
[01:29:32.964] {
[01:29:32.964]     {
[01:29:32.964]         {
[01:29:32.964]             ...future.startTime <- base::Sys.time()
[01:29:32.964]             {
[01:29:32.964]                 {
[01:29:32.964]                   {
[01:29:32.964]                     {
[01:29:32.964]                       base::local({
[01:29:32.964]                         has_future <- base::requireNamespace("future", 
[01:29:32.964]                           quietly = TRUE)
[01:29:32.964]                         if (has_future) {
[01:29:32.964]                           ns <- base::getNamespace("future")
[01:29:32.964]                           version <- ns[[".package"]][["version"]]
[01:29:32.964]                           if (is.null(version)) 
[01:29:32.964]                             version <- utils::packageVersion("future")
[01:29:32.964]                         }
[01:29:32.964]                         else {
[01:29:32.964]                           version <- NULL
[01:29:32.964]                         }
[01:29:32.964]                         if (!has_future || version < "1.8.0") {
[01:29:32.964]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:32.964]                             "", base::R.version$version.string), 
[01:29:32.964]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:32.964]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:32.964]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:32.964]                               "release", "version")], collapse = " "), 
[01:29:32.964]                             hostname = base::Sys.info()[["nodename"]])
[01:29:32.964]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:32.964]                             info)
[01:29:32.964]                           info <- base::paste(info, collapse = "; ")
[01:29:32.964]                           if (!has_future) {
[01:29:32.964]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:32.964]                               info)
[01:29:32.964]                           }
[01:29:32.964]                           else {
[01:29:32.964]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:32.964]                               info, version)
[01:29:32.964]                           }
[01:29:32.964]                           base::stop(msg)
[01:29:32.964]                         }
[01:29:32.964]                       })
[01:29:32.964]                     }
[01:29:32.964]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:32.964]                     base::options(mc.cores = 1L)
[01:29:32.964]                   }
[01:29:32.964]                   options(future.plan = NULL)
[01:29:32.964]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.964]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:32.964]                 }
[01:29:32.964]                 ...future.workdir <- getwd()
[01:29:32.964]             }
[01:29:32.964]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:32.964]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:32.964]         }
[01:29:32.964]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:32.964]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:32.964]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:32.964]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:32.964]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:32.964]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:32.964]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:32.964]             base::names(...future.oldOptions))
[01:29:32.964]     }
[01:29:32.964]     if (FALSE) {
[01:29:32.964]     }
[01:29:32.964]     else {
[01:29:32.964]         if (TRUE) {
[01:29:32.964]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:32.964]                 open = "w")
[01:29:32.964]         }
[01:29:32.964]         else {
[01:29:32.964]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:32.964]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:32.964]         }
[01:29:32.964]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:32.964]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:32.964]             base::sink(type = "output", split = FALSE)
[01:29:32.964]             base::close(...future.stdout)
[01:29:32.964]         }, add = TRUE)
[01:29:32.964]     }
[01:29:32.964]     ...future.frame <- base::sys.nframe()
[01:29:32.964]     ...future.conditions <- base::list()
[01:29:32.964]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:32.964]     if (FALSE) {
[01:29:32.964]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:32.964]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:32.964]     }
[01:29:32.964]     ...future.result <- base::tryCatch({
[01:29:32.964]         base::withCallingHandlers({
[01:29:32.964]             ...future.value <- base::withVisible(base::local({
[01:29:32.964]                 ...future.makeSendCondition <- base::local({
[01:29:32.964]                   sendCondition <- NULL
[01:29:32.964]                   function(frame = 1L) {
[01:29:32.964]                     if (is.function(sendCondition)) 
[01:29:32.964]                       return(sendCondition)
[01:29:32.964]                     ns <- getNamespace("parallel")
[01:29:32.964]                     if (exists("sendData", mode = "function", 
[01:29:32.964]                       envir = ns)) {
[01:29:32.964]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:32.964]                         envir = ns)
[01:29:32.964]                       envir <- sys.frame(frame)
[01:29:32.964]                       master <- NULL
[01:29:32.964]                       while (!identical(envir, .GlobalEnv) && 
[01:29:32.964]                         !identical(envir, emptyenv())) {
[01:29:32.964]                         if (exists("master", mode = "list", envir = envir, 
[01:29:32.964]                           inherits = FALSE)) {
[01:29:32.964]                           master <- get("master", mode = "list", 
[01:29:32.964]                             envir = envir, inherits = FALSE)
[01:29:32.964]                           if (inherits(master, c("SOCKnode", 
[01:29:32.964]                             "SOCK0node"))) {
[01:29:32.964]                             sendCondition <<- function(cond) {
[01:29:32.964]                               data <- list(type = "VALUE", value = cond, 
[01:29:32.964]                                 success = TRUE)
[01:29:32.964]                               parallel_sendData(master, data)
[01:29:32.964]                             }
[01:29:32.964]                             return(sendCondition)
[01:29:32.964]                           }
[01:29:32.964]                         }
[01:29:32.964]                         frame <- frame + 1L
[01:29:32.964]                         envir <- sys.frame(frame)
[01:29:32.964]                       }
[01:29:32.964]                     }
[01:29:32.964]                     sendCondition <<- function(cond) NULL
[01:29:32.964]                   }
[01:29:32.964]                 })
[01:29:32.964]                 withCallingHandlers({
[01:29:32.964]                   {
[01:29:32.964]                     sample(x, size = 1L)
[01:29:32.964]                   }
[01:29:32.964]                 }, immediateCondition = function(cond) {
[01:29:32.964]                   sendCondition <- ...future.makeSendCondition()
[01:29:32.964]                   sendCondition(cond)
[01:29:32.964]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.964]                   {
[01:29:32.964]                     inherits <- base::inherits
[01:29:32.964]                     invokeRestart <- base::invokeRestart
[01:29:32.964]                     is.null <- base::is.null
[01:29:32.964]                     muffled <- FALSE
[01:29:32.964]                     if (inherits(cond, "message")) {
[01:29:32.964]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:32.964]                       if (muffled) 
[01:29:32.964]                         invokeRestart("muffleMessage")
[01:29:32.964]                     }
[01:29:32.964]                     else if (inherits(cond, "warning")) {
[01:29:32.964]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:32.964]                       if (muffled) 
[01:29:32.964]                         invokeRestart("muffleWarning")
[01:29:32.964]                     }
[01:29:32.964]                     else if (inherits(cond, "condition")) {
[01:29:32.964]                       if (!is.null(pattern)) {
[01:29:32.964]                         computeRestarts <- base::computeRestarts
[01:29:32.964]                         grepl <- base::grepl
[01:29:32.964]                         restarts <- computeRestarts(cond)
[01:29:32.964]                         for (restart in restarts) {
[01:29:32.964]                           name <- restart$name
[01:29:32.964]                           if (is.null(name)) 
[01:29:32.964]                             next
[01:29:32.964]                           if (!grepl(pattern, name)) 
[01:29:32.964]                             next
[01:29:32.964]                           invokeRestart(restart)
[01:29:32.964]                           muffled <- TRUE
[01:29:32.964]                           break
[01:29:32.964]                         }
[01:29:32.964]                       }
[01:29:32.964]                     }
[01:29:32.964]                     invisible(muffled)
[01:29:32.964]                   }
[01:29:32.964]                   muffleCondition(cond)
[01:29:32.964]                 })
[01:29:32.964]             }))
[01:29:32.964]             future::FutureResult(value = ...future.value$value, 
[01:29:32.964]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.964]                   ...future.rng), globalenv = if (FALSE) 
[01:29:32.964]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:32.964]                     ...future.globalenv.names))
[01:29:32.964]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:32.964]         }, condition = base::local({
[01:29:32.964]             c <- base::c
[01:29:32.964]             inherits <- base::inherits
[01:29:32.964]             invokeRestart <- base::invokeRestart
[01:29:32.964]             length <- base::length
[01:29:32.964]             list <- base::list
[01:29:32.964]             seq.int <- base::seq.int
[01:29:32.964]             signalCondition <- base::signalCondition
[01:29:32.964]             sys.calls <- base::sys.calls
[01:29:32.964]             `[[` <- base::`[[`
[01:29:32.964]             `+` <- base::`+`
[01:29:32.964]             `<<-` <- base::`<<-`
[01:29:32.964]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:32.964]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:32.964]                   3L)]
[01:29:32.964]             }
[01:29:32.964]             function(cond) {
[01:29:32.964]                 is_error <- inherits(cond, "error")
[01:29:32.964]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:32.964]                   NULL)
[01:29:32.964]                 if (is_error) {
[01:29:32.964]                   sessionInformation <- function() {
[01:29:32.964]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:32.964]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:32.964]                       search = base::search(), system = base::Sys.info())
[01:29:32.964]                   }
[01:29:32.964]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.964]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:32.964]                     cond$call), session = sessionInformation(), 
[01:29:32.964]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:32.964]                   signalCondition(cond)
[01:29:32.964]                 }
[01:29:32.964]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:32.964]                 "immediateCondition"))) {
[01:29:32.964]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:32.964]                   ...future.conditions[[length(...future.conditions) + 
[01:29:32.964]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:32.964]                   if (TRUE && !signal) {
[01:29:32.964]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.964]                     {
[01:29:32.964]                       inherits <- base::inherits
[01:29:32.964]                       invokeRestart <- base::invokeRestart
[01:29:32.964]                       is.null <- base::is.null
[01:29:32.964]                       muffled <- FALSE
[01:29:32.964]                       if (inherits(cond, "message")) {
[01:29:32.964]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.964]                         if (muffled) 
[01:29:32.964]                           invokeRestart("muffleMessage")
[01:29:32.964]                       }
[01:29:32.964]                       else if (inherits(cond, "warning")) {
[01:29:32.964]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.964]                         if (muffled) 
[01:29:32.964]                           invokeRestart("muffleWarning")
[01:29:32.964]                       }
[01:29:32.964]                       else if (inherits(cond, "condition")) {
[01:29:32.964]                         if (!is.null(pattern)) {
[01:29:32.964]                           computeRestarts <- base::computeRestarts
[01:29:32.964]                           grepl <- base::grepl
[01:29:32.964]                           restarts <- computeRestarts(cond)
[01:29:32.964]                           for (restart in restarts) {
[01:29:32.964]                             name <- restart$name
[01:29:32.964]                             if (is.null(name)) 
[01:29:32.964]                               next
[01:29:32.964]                             if (!grepl(pattern, name)) 
[01:29:32.964]                               next
[01:29:32.964]                             invokeRestart(restart)
[01:29:32.964]                             muffled <- TRUE
[01:29:32.964]                             break
[01:29:32.964]                           }
[01:29:32.964]                         }
[01:29:32.964]                       }
[01:29:32.964]                       invisible(muffled)
[01:29:32.964]                     }
[01:29:32.964]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.964]                   }
[01:29:32.964]                 }
[01:29:32.964]                 else {
[01:29:32.964]                   if (TRUE) {
[01:29:32.964]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:32.964]                     {
[01:29:32.964]                       inherits <- base::inherits
[01:29:32.964]                       invokeRestart <- base::invokeRestart
[01:29:32.964]                       is.null <- base::is.null
[01:29:32.964]                       muffled <- FALSE
[01:29:32.964]                       if (inherits(cond, "message")) {
[01:29:32.964]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:32.964]                         if (muffled) 
[01:29:32.964]                           invokeRestart("muffleMessage")
[01:29:32.964]                       }
[01:29:32.964]                       else if (inherits(cond, "warning")) {
[01:29:32.964]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:32.964]                         if (muffled) 
[01:29:32.964]                           invokeRestart("muffleWarning")
[01:29:32.964]                       }
[01:29:32.964]                       else if (inherits(cond, "condition")) {
[01:29:32.964]                         if (!is.null(pattern)) {
[01:29:32.964]                           computeRestarts <- base::computeRestarts
[01:29:32.964]                           grepl <- base::grepl
[01:29:32.964]                           restarts <- computeRestarts(cond)
[01:29:32.964]                           for (restart in restarts) {
[01:29:32.964]                             name <- restart$name
[01:29:32.964]                             if (is.null(name)) 
[01:29:32.964]                               next
[01:29:32.964]                             if (!grepl(pattern, name)) 
[01:29:32.964]                               next
[01:29:32.964]                             invokeRestart(restart)
[01:29:32.964]                             muffled <- TRUE
[01:29:32.964]                             break
[01:29:32.964]                           }
[01:29:32.964]                         }
[01:29:32.964]                       }
[01:29:32.964]                       invisible(muffled)
[01:29:32.964]                     }
[01:29:32.964]                     muffleCondition(cond, pattern = "^muffle")
[01:29:32.964]                   }
[01:29:32.964]                 }
[01:29:32.964]             }
[01:29:32.964]         }))
[01:29:32.964]     }, error = function(ex) {
[01:29:32.964]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:32.964]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:32.964]                 ...future.rng), started = ...future.startTime, 
[01:29:32.964]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:32.964]             version = "1.8"), class = "FutureResult")
[01:29:32.964]     }, finally = {
[01:29:32.964]         if (!identical(...future.workdir, getwd())) 
[01:29:32.964]             setwd(...future.workdir)
[01:29:32.964]         {
[01:29:32.964]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:32.964]                 ...future.oldOptions$nwarnings <- NULL
[01:29:32.964]             }
[01:29:32.964]             base::options(...future.oldOptions)
[01:29:32.964]             if (.Platform$OS.type == "windows") {
[01:29:32.964]                 old_names <- names(...future.oldEnvVars)
[01:29:32.964]                 envs <- base::Sys.getenv()
[01:29:32.964]                 names <- names(envs)
[01:29:32.964]                 common <- intersect(names, old_names)
[01:29:32.964]                 added <- setdiff(names, old_names)
[01:29:32.964]                 removed <- setdiff(old_names, names)
[01:29:32.964]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:32.964]                   envs[common]]
[01:29:32.964]                 NAMES <- toupper(changed)
[01:29:32.964]                 args <- list()
[01:29:32.964]                 for (kk in seq_along(NAMES)) {
[01:29:32.964]                   name <- changed[[kk]]
[01:29:32.964]                   NAME <- NAMES[[kk]]
[01:29:32.964]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.964]                     next
[01:29:32.964]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.964]                 }
[01:29:32.964]                 NAMES <- toupper(added)
[01:29:32.964]                 for (kk in seq_along(NAMES)) {
[01:29:32.964]                   name <- added[[kk]]
[01:29:32.964]                   NAME <- NAMES[[kk]]
[01:29:32.964]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.964]                     next
[01:29:32.964]                   args[[name]] <- ""
[01:29:32.964]                 }
[01:29:32.964]                 NAMES <- toupper(removed)
[01:29:32.964]                 for (kk in seq_along(NAMES)) {
[01:29:32.964]                   name <- removed[[kk]]
[01:29:32.964]                   NAME <- NAMES[[kk]]
[01:29:32.964]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:32.964]                     next
[01:29:32.964]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:32.964]                 }
[01:29:32.964]                 if (length(args) > 0) 
[01:29:32.964]                   base::do.call(base::Sys.setenv, args = args)
[01:29:32.964]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:32.964]             }
[01:29:32.964]             else {
[01:29:32.964]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:32.964]             }
[01:29:32.964]             {
[01:29:32.964]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:32.964]                   0L) {
[01:29:32.964]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:32.964]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:32.964]                   base::options(opts)
[01:29:32.964]                 }
[01:29:32.964]                 {
[01:29:32.964]                   {
[01:29:32.964]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:32.964]                     NULL
[01:29:32.964]                   }
[01:29:32.964]                   options(future.plan = NULL)
[01:29:32.964]                   if (is.na(NA_character_)) 
[01:29:32.964]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:32.964]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:32.964]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:32.964]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:32.964]                     envir = parent.frame()) 
[01:29:32.964]                   {
[01:29:32.964]                     if (is.function(workers)) 
[01:29:32.964]                       workers <- workers()
[01:29:32.964]                     workers <- structure(as.integer(workers), 
[01:29:32.964]                       class = class(workers))
[01:29:32.964]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:32.964]                       workers >= 1)
[01:29:32.964]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:32.964]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:32.964]                     }
[01:29:32.964]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:32.964]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:32.964]                       envir = envir)
[01:29:32.964]                     if (!future$lazy) 
[01:29:32.964]                       future <- run(future)
[01:29:32.964]                     invisible(future)
[01:29:32.964]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:32.964]                 }
[01:29:32.964]             }
[01:29:32.964]         }
[01:29:32.964]     })
[01:29:32.964]     if (TRUE) {
[01:29:32.964]         base::sink(type = "output", split = FALSE)
[01:29:32.964]         if (TRUE) {
[01:29:32.964]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:32.964]         }
[01:29:32.964]         else {
[01:29:32.964]             ...future.result["stdout"] <- base::list(NULL)
[01:29:32.964]         }
[01:29:32.964]         base::close(...future.stdout)
[01:29:32.964]         ...future.stdout <- NULL
[01:29:32.964]     }
[01:29:32.964]     ...future.result$conditions <- ...future.conditions
[01:29:32.964]     ...future.result$finished <- base::Sys.time()
[01:29:32.964]     ...future.result
[01:29:32.964] }
[01:29:32.970] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:32.971] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:32.971] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:32.971] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:32.972] MultisessionFuture started
[01:29:32.973] - Launch lazy future ... done
[01:29:32.973] run() for 'MultisessionFuture' ... done
[01:29:32.974] getGlobalsAndPackages() ...
[01:29:32.974] Searching for globals...
[01:29:32.975] - globals found: [3] '{', 'sample', 'x'
[01:29:32.976] Searching for globals ... DONE
[01:29:32.976] Resolving globals: FALSE
[01:29:32.976] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:32.977] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:32.977] - globals: [1] 'x'
[01:29:32.977] 
[01:29:32.978] getGlobalsAndPackages() ... DONE
[01:29:32.978] run() for 'Future' ...
[01:29:32.978] - state: 'created'
[01:29:32.978] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:32.995] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:32.995] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:32.995]   - Field: 'node'
[01:29:32.996]   - Field: 'label'
[01:29:32.996]   - Field: 'local'
[01:29:32.996]   - Field: 'owner'
[01:29:32.996]   - Field: 'envir'
[01:29:32.996]   - Field: 'workers'
[01:29:32.997]   - Field: 'packages'
[01:29:32.997]   - Field: 'gc'
[01:29:32.997]   - Field: 'conditions'
[01:29:32.997]   - Field: 'persistent'
[01:29:32.997]   - Field: 'expr'
[01:29:32.998]   - Field: 'uuid'
[01:29:32.998]   - Field: 'seed'
[01:29:32.998]   - Field: 'version'
[01:29:32.998]   - Field: 'result'
[01:29:32.998]   - Field: 'asynchronous'
[01:29:32.999]   - Field: 'calls'
[01:29:32.999]   - Field: 'globals'
[01:29:32.999]   - Field: 'stdout'
[01:29:32.999]   - Field: 'earlySignal'
[01:29:32.999]   - Field: 'lazy'
[01:29:33.000]   - Field: 'state'
[01:29:33.000] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:33.000] - Launch lazy future ...
[01:29:33.000] Packages needed by the future expression (n = 0): <none>
[01:29:33.001] Packages needed by future strategies (n = 0): <none>
[01:29:33.002] {
[01:29:33.002]     {
[01:29:33.002]         {
[01:29:33.002]             ...future.startTime <- base::Sys.time()
[01:29:33.002]             {
[01:29:33.002]                 {
[01:29:33.002]                   {
[01:29:33.002]                     {
[01:29:33.002]                       base::local({
[01:29:33.002]                         has_future <- base::requireNamespace("future", 
[01:29:33.002]                           quietly = TRUE)
[01:29:33.002]                         if (has_future) {
[01:29:33.002]                           ns <- base::getNamespace("future")
[01:29:33.002]                           version <- ns[[".package"]][["version"]]
[01:29:33.002]                           if (is.null(version)) 
[01:29:33.002]                             version <- utils::packageVersion("future")
[01:29:33.002]                         }
[01:29:33.002]                         else {
[01:29:33.002]                           version <- NULL
[01:29:33.002]                         }
[01:29:33.002]                         if (!has_future || version < "1.8.0") {
[01:29:33.002]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:33.002]                             "", base::R.version$version.string), 
[01:29:33.002]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:33.002]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:33.002]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:33.002]                               "release", "version")], collapse = " "), 
[01:29:33.002]                             hostname = base::Sys.info()[["nodename"]])
[01:29:33.002]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:33.002]                             info)
[01:29:33.002]                           info <- base::paste(info, collapse = "; ")
[01:29:33.002]                           if (!has_future) {
[01:29:33.002]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:33.002]                               info)
[01:29:33.002]                           }
[01:29:33.002]                           else {
[01:29:33.002]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:33.002]                               info, version)
[01:29:33.002]                           }
[01:29:33.002]                           base::stop(msg)
[01:29:33.002]                         }
[01:29:33.002]                       })
[01:29:33.002]                     }
[01:29:33.002]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:33.002]                     base::options(mc.cores = 1L)
[01:29:33.002]                   }
[01:29:33.002]                   options(future.plan = NULL)
[01:29:33.002]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:33.002]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:33.002]                 }
[01:29:33.002]                 ...future.workdir <- getwd()
[01:29:33.002]             }
[01:29:33.002]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:33.002]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:33.002]         }
[01:29:33.002]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:33.002]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:33.002]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:33.002]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:33.002]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:33.002]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:33.002]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:33.002]             base::names(...future.oldOptions))
[01:29:33.002]     }
[01:29:33.002]     if (FALSE) {
[01:29:33.002]     }
[01:29:33.002]     else {
[01:29:33.002]         if (TRUE) {
[01:29:33.002]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:33.002]                 open = "w")
[01:29:33.002]         }
[01:29:33.002]         else {
[01:29:33.002]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:33.002]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:33.002]         }
[01:29:33.002]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:33.002]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:33.002]             base::sink(type = "output", split = FALSE)
[01:29:33.002]             base::close(...future.stdout)
[01:29:33.002]         }, add = TRUE)
[01:29:33.002]     }
[01:29:33.002]     ...future.frame <- base::sys.nframe()
[01:29:33.002]     ...future.conditions <- base::list()
[01:29:33.002]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:33.002]     if (FALSE) {
[01:29:33.002]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:33.002]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:33.002]     }
[01:29:33.002]     ...future.result <- base::tryCatch({
[01:29:33.002]         base::withCallingHandlers({
[01:29:33.002]             ...future.value <- base::withVisible(base::local({
[01:29:33.002]                 ...future.makeSendCondition <- base::local({
[01:29:33.002]                   sendCondition <- NULL
[01:29:33.002]                   function(frame = 1L) {
[01:29:33.002]                     if (is.function(sendCondition)) 
[01:29:33.002]                       return(sendCondition)
[01:29:33.002]                     ns <- getNamespace("parallel")
[01:29:33.002]                     if (exists("sendData", mode = "function", 
[01:29:33.002]                       envir = ns)) {
[01:29:33.002]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:33.002]                         envir = ns)
[01:29:33.002]                       envir <- sys.frame(frame)
[01:29:33.002]                       master <- NULL
[01:29:33.002]                       while (!identical(envir, .GlobalEnv) && 
[01:29:33.002]                         !identical(envir, emptyenv())) {
[01:29:33.002]                         if (exists("master", mode = "list", envir = envir, 
[01:29:33.002]                           inherits = FALSE)) {
[01:29:33.002]                           master <- get("master", mode = "list", 
[01:29:33.002]                             envir = envir, inherits = FALSE)
[01:29:33.002]                           if (inherits(master, c("SOCKnode", 
[01:29:33.002]                             "SOCK0node"))) {
[01:29:33.002]                             sendCondition <<- function(cond) {
[01:29:33.002]                               data <- list(type = "VALUE", value = cond, 
[01:29:33.002]                                 success = TRUE)
[01:29:33.002]                               parallel_sendData(master, data)
[01:29:33.002]                             }
[01:29:33.002]                             return(sendCondition)
[01:29:33.002]                           }
[01:29:33.002]                         }
[01:29:33.002]                         frame <- frame + 1L
[01:29:33.002]                         envir <- sys.frame(frame)
[01:29:33.002]                       }
[01:29:33.002]                     }
[01:29:33.002]                     sendCondition <<- function(cond) NULL
[01:29:33.002]                   }
[01:29:33.002]                 })
[01:29:33.002]                 withCallingHandlers({
[01:29:33.002]                   {
[01:29:33.002]                     sample(x, size = 1L)
[01:29:33.002]                   }
[01:29:33.002]                 }, immediateCondition = function(cond) {
[01:29:33.002]                   sendCondition <- ...future.makeSendCondition()
[01:29:33.002]                   sendCondition(cond)
[01:29:33.002]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.002]                   {
[01:29:33.002]                     inherits <- base::inherits
[01:29:33.002]                     invokeRestart <- base::invokeRestart
[01:29:33.002]                     is.null <- base::is.null
[01:29:33.002]                     muffled <- FALSE
[01:29:33.002]                     if (inherits(cond, "message")) {
[01:29:33.002]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:33.002]                       if (muffled) 
[01:29:33.002]                         invokeRestart("muffleMessage")
[01:29:33.002]                     }
[01:29:33.002]                     else if (inherits(cond, "warning")) {
[01:29:33.002]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:33.002]                       if (muffled) 
[01:29:33.002]                         invokeRestart("muffleWarning")
[01:29:33.002]                     }
[01:29:33.002]                     else if (inherits(cond, "condition")) {
[01:29:33.002]                       if (!is.null(pattern)) {
[01:29:33.002]                         computeRestarts <- base::computeRestarts
[01:29:33.002]                         grepl <- base::grepl
[01:29:33.002]                         restarts <- computeRestarts(cond)
[01:29:33.002]                         for (restart in restarts) {
[01:29:33.002]                           name <- restart$name
[01:29:33.002]                           if (is.null(name)) 
[01:29:33.002]                             next
[01:29:33.002]                           if (!grepl(pattern, name)) 
[01:29:33.002]                             next
[01:29:33.002]                           invokeRestart(restart)
[01:29:33.002]                           muffled <- TRUE
[01:29:33.002]                           break
[01:29:33.002]                         }
[01:29:33.002]                       }
[01:29:33.002]                     }
[01:29:33.002]                     invisible(muffled)
[01:29:33.002]                   }
[01:29:33.002]                   muffleCondition(cond)
[01:29:33.002]                 })
[01:29:33.002]             }))
[01:29:33.002]             future::FutureResult(value = ...future.value$value, 
[01:29:33.002]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:33.002]                   ...future.rng), globalenv = if (FALSE) 
[01:29:33.002]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:33.002]                     ...future.globalenv.names))
[01:29:33.002]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:33.002]         }, condition = base::local({
[01:29:33.002]             c <- base::c
[01:29:33.002]             inherits <- base::inherits
[01:29:33.002]             invokeRestart <- base::invokeRestart
[01:29:33.002]             length <- base::length
[01:29:33.002]             list <- base::list
[01:29:33.002]             seq.int <- base::seq.int
[01:29:33.002]             signalCondition <- base::signalCondition
[01:29:33.002]             sys.calls <- base::sys.calls
[01:29:33.002]             `[[` <- base::`[[`
[01:29:33.002]             `+` <- base::`+`
[01:29:33.002]             `<<-` <- base::`<<-`
[01:29:33.002]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:33.002]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:33.002]                   3L)]
[01:29:33.002]             }
[01:29:33.002]             function(cond) {
[01:29:33.002]                 is_error <- inherits(cond, "error")
[01:29:33.002]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:33.002]                   NULL)
[01:29:33.002]                 if (is_error) {
[01:29:33.002]                   sessionInformation <- function() {
[01:29:33.002]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:33.002]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:33.002]                       search = base::search(), system = base::Sys.info())
[01:29:33.002]                   }
[01:29:33.002]                   ...future.conditions[[length(...future.conditions) + 
[01:29:33.002]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:33.002]                     cond$call), session = sessionInformation(), 
[01:29:33.002]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:33.002]                   signalCondition(cond)
[01:29:33.002]                 }
[01:29:33.002]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:33.002]                 "immediateCondition"))) {
[01:29:33.002]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:33.002]                   ...future.conditions[[length(...future.conditions) + 
[01:29:33.002]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:33.002]                   if (TRUE && !signal) {
[01:29:33.002]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.002]                     {
[01:29:33.002]                       inherits <- base::inherits
[01:29:33.002]                       invokeRestart <- base::invokeRestart
[01:29:33.002]                       is.null <- base::is.null
[01:29:33.002]                       muffled <- FALSE
[01:29:33.002]                       if (inherits(cond, "message")) {
[01:29:33.002]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:33.002]                         if (muffled) 
[01:29:33.002]                           invokeRestart("muffleMessage")
[01:29:33.002]                       }
[01:29:33.002]                       else if (inherits(cond, "warning")) {
[01:29:33.002]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:33.002]                         if (muffled) 
[01:29:33.002]                           invokeRestart("muffleWarning")
[01:29:33.002]                       }
[01:29:33.002]                       else if (inherits(cond, "condition")) {
[01:29:33.002]                         if (!is.null(pattern)) {
[01:29:33.002]                           computeRestarts <- base::computeRestarts
[01:29:33.002]                           grepl <- base::grepl
[01:29:33.002]                           restarts <- computeRestarts(cond)
[01:29:33.002]                           for (restart in restarts) {
[01:29:33.002]                             name <- restart$name
[01:29:33.002]                             if (is.null(name)) 
[01:29:33.002]                               next
[01:29:33.002]                             if (!grepl(pattern, name)) 
[01:29:33.002]                               next
[01:29:33.002]                             invokeRestart(restart)
[01:29:33.002]                             muffled <- TRUE
[01:29:33.002]                             break
[01:29:33.002]                           }
[01:29:33.002]                         }
[01:29:33.002]                       }
[01:29:33.002]                       invisible(muffled)
[01:29:33.002]                     }
[01:29:33.002]                     muffleCondition(cond, pattern = "^muffle")
[01:29:33.002]                   }
[01:29:33.002]                 }
[01:29:33.002]                 else {
[01:29:33.002]                   if (TRUE) {
[01:29:33.002]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.002]                     {
[01:29:33.002]                       inherits <- base::inherits
[01:29:33.002]                       invokeRestart <- base::invokeRestart
[01:29:33.002]                       is.null <- base::is.null
[01:29:33.002]                       muffled <- FALSE
[01:29:33.002]                       if (inherits(cond, "message")) {
[01:29:33.002]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:33.002]                         if (muffled) 
[01:29:33.002]                           invokeRestart("muffleMessage")
[01:29:33.002]                       }
[01:29:33.002]                       else if (inherits(cond, "warning")) {
[01:29:33.002]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:33.002]                         if (muffled) 
[01:29:33.002]                           invokeRestart("muffleWarning")
[01:29:33.002]                       }
[01:29:33.002]                       else if (inherits(cond, "condition")) {
[01:29:33.002]                         if (!is.null(pattern)) {
[01:29:33.002]                           computeRestarts <- base::computeRestarts
[01:29:33.002]                           grepl <- base::grepl
[01:29:33.002]                           restarts <- computeRestarts(cond)
[01:29:33.002]                           for (restart in restarts) {
[01:29:33.002]                             name <- restart$name
[01:29:33.002]                             if (is.null(name)) 
[01:29:33.002]                               next
[01:29:33.002]                             if (!grepl(pattern, name)) 
[01:29:33.002]                               next
[01:29:33.002]                             invokeRestart(restart)
[01:29:33.002]                             muffled <- TRUE
[01:29:33.002]                             break
[01:29:33.002]                           }
[01:29:33.002]                         }
[01:29:33.002]                       }
[01:29:33.002]                       invisible(muffled)
[01:29:33.002]                     }
[01:29:33.002]                     muffleCondition(cond, pattern = "^muffle")
[01:29:33.002]                   }
[01:29:33.002]                 }
[01:29:33.002]             }
[01:29:33.002]         }))
[01:29:33.002]     }, error = function(ex) {
[01:29:33.002]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:33.002]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:33.002]                 ...future.rng), started = ...future.startTime, 
[01:29:33.002]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:33.002]             version = "1.8"), class = "FutureResult")
[01:29:33.002]     }, finally = {
[01:29:33.002]         if (!identical(...future.workdir, getwd())) 
[01:29:33.002]             setwd(...future.workdir)
[01:29:33.002]         {
[01:29:33.002]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:33.002]                 ...future.oldOptions$nwarnings <- NULL
[01:29:33.002]             }
[01:29:33.002]             base::options(...future.oldOptions)
[01:29:33.002]             if (.Platform$OS.type == "windows") {
[01:29:33.002]                 old_names <- names(...future.oldEnvVars)
[01:29:33.002]                 envs <- base::Sys.getenv()
[01:29:33.002]                 names <- names(envs)
[01:29:33.002]                 common <- intersect(names, old_names)
[01:29:33.002]                 added <- setdiff(names, old_names)
[01:29:33.002]                 removed <- setdiff(old_names, names)
[01:29:33.002]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:33.002]                   envs[common]]
[01:29:33.002]                 NAMES <- toupper(changed)
[01:29:33.002]                 args <- list()
[01:29:33.002]                 for (kk in seq_along(NAMES)) {
[01:29:33.002]                   name <- changed[[kk]]
[01:29:33.002]                   NAME <- NAMES[[kk]]
[01:29:33.002]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.002]                     next
[01:29:33.002]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:33.002]                 }
[01:29:33.002]                 NAMES <- toupper(added)
[01:29:33.002]                 for (kk in seq_along(NAMES)) {
[01:29:33.002]                   name <- added[[kk]]
[01:29:33.002]                   NAME <- NAMES[[kk]]
[01:29:33.002]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.002]                     next
[01:29:33.002]                   args[[name]] <- ""
[01:29:33.002]                 }
[01:29:33.002]                 NAMES <- toupper(removed)
[01:29:33.002]                 for (kk in seq_along(NAMES)) {
[01:29:33.002]                   name <- removed[[kk]]
[01:29:33.002]                   NAME <- NAMES[[kk]]
[01:29:33.002]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.002]                     next
[01:29:33.002]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:33.002]                 }
[01:29:33.002]                 if (length(args) > 0) 
[01:29:33.002]                   base::do.call(base::Sys.setenv, args = args)
[01:29:33.002]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:33.002]             }
[01:29:33.002]             else {
[01:29:33.002]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:33.002]             }
[01:29:33.002]             {
[01:29:33.002]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:33.002]                   0L) {
[01:29:33.002]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:33.002]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:33.002]                   base::options(opts)
[01:29:33.002]                 }
[01:29:33.002]                 {
[01:29:33.002]                   {
[01:29:33.002]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:33.002]                     NULL
[01:29:33.002]                   }
[01:29:33.002]                   options(future.plan = NULL)
[01:29:33.002]                   if (is.na(NA_character_)) 
[01:29:33.002]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:33.002]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:33.002]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:33.002]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:33.002]                     envir = parent.frame()) 
[01:29:33.002]                   {
[01:29:33.002]                     if (is.function(workers)) 
[01:29:33.002]                       workers <- workers()
[01:29:33.002]                     workers <- structure(as.integer(workers), 
[01:29:33.002]                       class = class(workers))
[01:29:33.002]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:33.002]                       workers >= 1)
[01:29:33.002]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:33.002]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:33.002]                     }
[01:29:33.002]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:33.002]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:33.002]                       envir = envir)
[01:29:33.002]                     if (!future$lazy) 
[01:29:33.002]                       future <- run(future)
[01:29:33.002]                     invisible(future)
[01:29:33.002]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:33.002]                 }
[01:29:33.002]             }
[01:29:33.002]         }
[01:29:33.002]     })
[01:29:33.002]     if (TRUE) {
[01:29:33.002]         base::sink(type = "output", split = FALSE)
[01:29:33.002]         if (TRUE) {
[01:29:33.002]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:33.002]         }
[01:29:33.002]         else {
[01:29:33.002]             ...future.result["stdout"] <- base::list(NULL)
[01:29:33.002]         }
[01:29:33.002]         base::close(...future.stdout)
[01:29:33.002]         ...future.stdout <- NULL
[01:29:33.002]     }
[01:29:33.002]     ...future.result$conditions <- ...future.conditions
[01:29:33.002]     ...future.result$finished <- base::Sys.time()
[01:29:33.002]     ...future.result
[01:29:33.002] }
[01:29:33.008] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:33.008] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:33.009] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:33.009] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:33.010] MultisessionFuture started
[01:29:33.010] - Launch lazy future ... done
[01:29:33.010] run() for 'MultisessionFuture' ... done
[01:29:33.011] getGlobalsAndPackages() ...
[01:29:33.011] Searching for globals...
[01:29:33.013] - globals found: [3] '{', 'sample', 'x'
[01:29:33.013] Searching for globals ... DONE
[01:29:33.014] Resolving globals: FALSE
[01:29:33.014] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:33.015] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:33.015] - globals: [1] 'x'
[01:29:33.015] 
[01:29:33.016] getGlobalsAndPackages() ... DONE
[01:29:33.016] run() for 'Future' ...
[01:29:33.016] - state: 'created'
[01:29:33.017] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:33.034] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:33.034] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:33.035]   - Field: 'node'
[01:29:33.035]   - Field: 'label'
[01:29:33.035]   - Field: 'local'
[01:29:33.035]   - Field: 'owner'
[01:29:33.036]   - Field: 'envir'
[01:29:33.036]   - Field: 'workers'
[01:29:33.036]   - Field: 'packages'
[01:29:33.036]   - Field: 'gc'
[01:29:33.036]   - Field: 'conditions'
[01:29:33.037]   - Field: 'persistent'
[01:29:33.037]   - Field: 'expr'
[01:29:33.037]   - Field: 'uuid'
[01:29:33.037]   - Field: 'seed'
[01:29:33.037]   - Field: 'version'
[01:29:33.038]   - Field: 'result'
[01:29:33.038]   - Field: 'asynchronous'
[01:29:33.038]   - Field: 'calls'
[01:29:33.038]   - Field: 'globals'
[01:29:33.038]   - Field: 'stdout'
[01:29:33.039]   - Field: 'earlySignal'
[01:29:33.039]   - Field: 'lazy'
[01:29:33.039]   - Field: 'state'
[01:29:33.039] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:33.039] - Launch lazy future ...
[01:29:33.040] Packages needed by the future expression (n = 0): <none>
[01:29:33.040] Packages needed by future strategies (n = 0): <none>
[01:29:33.041] {
[01:29:33.041]     {
[01:29:33.041]         {
[01:29:33.041]             ...future.startTime <- base::Sys.time()
[01:29:33.041]             {
[01:29:33.041]                 {
[01:29:33.041]                   {
[01:29:33.041]                     {
[01:29:33.041]                       base::local({
[01:29:33.041]                         has_future <- base::requireNamespace("future", 
[01:29:33.041]                           quietly = TRUE)
[01:29:33.041]                         if (has_future) {
[01:29:33.041]                           ns <- base::getNamespace("future")
[01:29:33.041]                           version <- ns[[".package"]][["version"]]
[01:29:33.041]                           if (is.null(version)) 
[01:29:33.041]                             version <- utils::packageVersion("future")
[01:29:33.041]                         }
[01:29:33.041]                         else {
[01:29:33.041]                           version <- NULL
[01:29:33.041]                         }
[01:29:33.041]                         if (!has_future || version < "1.8.0") {
[01:29:33.041]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:33.041]                             "", base::R.version$version.string), 
[01:29:33.041]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:33.041]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:33.041]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:33.041]                               "release", "version")], collapse = " "), 
[01:29:33.041]                             hostname = base::Sys.info()[["nodename"]])
[01:29:33.041]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:33.041]                             info)
[01:29:33.041]                           info <- base::paste(info, collapse = "; ")
[01:29:33.041]                           if (!has_future) {
[01:29:33.041]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:33.041]                               info)
[01:29:33.041]                           }
[01:29:33.041]                           else {
[01:29:33.041]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:33.041]                               info, version)
[01:29:33.041]                           }
[01:29:33.041]                           base::stop(msg)
[01:29:33.041]                         }
[01:29:33.041]                       })
[01:29:33.041]                     }
[01:29:33.041]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:33.041]                     base::options(mc.cores = 1L)
[01:29:33.041]                   }
[01:29:33.041]                   options(future.plan = NULL)
[01:29:33.041]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:33.041]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:33.041]                 }
[01:29:33.041]                 ...future.workdir <- getwd()
[01:29:33.041]             }
[01:29:33.041]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:33.041]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:33.041]         }
[01:29:33.041]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:33.041]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:33.041]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:33.041]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:33.041]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:33.041]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:33.041]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:33.041]             base::names(...future.oldOptions))
[01:29:33.041]     }
[01:29:33.041]     if (FALSE) {
[01:29:33.041]     }
[01:29:33.041]     else {
[01:29:33.041]         if (TRUE) {
[01:29:33.041]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:33.041]                 open = "w")
[01:29:33.041]         }
[01:29:33.041]         else {
[01:29:33.041]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:33.041]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:33.041]         }
[01:29:33.041]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:33.041]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:33.041]             base::sink(type = "output", split = FALSE)
[01:29:33.041]             base::close(...future.stdout)
[01:29:33.041]         }, add = TRUE)
[01:29:33.041]     }
[01:29:33.041]     ...future.frame <- base::sys.nframe()
[01:29:33.041]     ...future.conditions <- base::list()
[01:29:33.041]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:33.041]     if (FALSE) {
[01:29:33.041]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:33.041]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:33.041]     }
[01:29:33.041]     ...future.result <- base::tryCatch({
[01:29:33.041]         base::withCallingHandlers({
[01:29:33.041]             ...future.value <- base::withVisible(base::local({
[01:29:33.041]                 ...future.makeSendCondition <- base::local({
[01:29:33.041]                   sendCondition <- NULL
[01:29:33.041]                   function(frame = 1L) {
[01:29:33.041]                     if (is.function(sendCondition)) 
[01:29:33.041]                       return(sendCondition)
[01:29:33.041]                     ns <- getNamespace("parallel")
[01:29:33.041]                     if (exists("sendData", mode = "function", 
[01:29:33.041]                       envir = ns)) {
[01:29:33.041]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:33.041]                         envir = ns)
[01:29:33.041]                       envir <- sys.frame(frame)
[01:29:33.041]                       master <- NULL
[01:29:33.041]                       while (!identical(envir, .GlobalEnv) && 
[01:29:33.041]                         !identical(envir, emptyenv())) {
[01:29:33.041]                         if (exists("master", mode = "list", envir = envir, 
[01:29:33.041]                           inherits = FALSE)) {
[01:29:33.041]                           master <- get("master", mode = "list", 
[01:29:33.041]                             envir = envir, inherits = FALSE)
[01:29:33.041]                           if (inherits(master, c("SOCKnode", 
[01:29:33.041]                             "SOCK0node"))) {
[01:29:33.041]                             sendCondition <<- function(cond) {
[01:29:33.041]                               data <- list(type = "VALUE", value = cond, 
[01:29:33.041]                                 success = TRUE)
[01:29:33.041]                               parallel_sendData(master, data)
[01:29:33.041]                             }
[01:29:33.041]                             return(sendCondition)
[01:29:33.041]                           }
[01:29:33.041]                         }
[01:29:33.041]                         frame <- frame + 1L
[01:29:33.041]                         envir <- sys.frame(frame)
[01:29:33.041]                       }
[01:29:33.041]                     }
[01:29:33.041]                     sendCondition <<- function(cond) NULL
[01:29:33.041]                   }
[01:29:33.041]                 })
[01:29:33.041]                 withCallingHandlers({
[01:29:33.041]                   {
[01:29:33.041]                     sample(x, size = 1L)
[01:29:33.041]                   }
[01:29:33.041]                 }, immediateCondition = function(cond) {
[01:29:33.041]                   sendCondition <- ...future.makeSendCondition()
[01:29:33.041]                   sendCondition(cond)
[01:29:33.041]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.041]                   {
[01:29:33.041]                     inherits <- base::inherits
[01:29:33.041]                     invokeRestart <- base::invokeRestart
[01:29:33.041]                     is.null <- base::is.null
[01:29:33.041]                     muffled <- FALSE
[01:29:33.041]                     if (inherits(cond, "message")) {
[01:29:33.041]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:33.041]                       if (muffled) 
[01:29:33.041]                         invokeRestart("muffleMessage")
[01:29:33.041]                     }
[01:29:33.041]                     else if (inherits(cond, "warning")) {
[01:29:33.041]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:33.041]                       if (muffled) 
[01:29:33.041]                         invokeRestart("muffleWarning")
[01:29:33.041]                     }
[01:29:33.041]                     else if (inherits(cond, "condition")) {
[01:29:33.041]                       if (!is.null(pattern)) {
[01:29:33.041]                         computeRestarts <- base::computeRestarts
[01:29:33.041]                         grepl <- base::grepl
[01:29:33.041]                         restarts <- computeRestarts(cond)
[01:29:33.041]                         for (restart in restarts) {
[01:29:33.041]                           name <- restart$name
[01:29:33.041]                           if (is.null(name)) 
[01:29:33.041]                             next
[01:29:33.041]                           if (!grepl(pattern, name)) 
[01:29:33.041]                             next
[01:29:33.041]                           invokeRestart(restart)
[01:29:33.041]                           muffled <- TRUE
[01:29:33.041]                           break
[01:29:33.041]                         }
[01:29:33.041]                       }
[01:29:33.041]                     }
[01:29:33.041]                     invisible(muffled)
[01:29:33.041]                   }
[01:29:33.041]                   muffleCondition(cond)
[01:29:33.041]                 })
[01:29:33.041]             }))
[01:29:33.041]             future::FutureResult(value = ...future.value$value, 
[01:29:33.041]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:33.041]                   ...future.rng), globalenv = if (FALSE) 
[01:29:33.041]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:33.041]                     ...future.globalenv.names))
[01:29:33.041]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:33.041]         }, condition = base::local({
[01:29:33.041]             c <- base::c
[01:29:33.041]             inherits <- base::inherits
[01:29:33.041]             invokeRestart <- base::invokeRestart
[01:29:33.041]             length <- base::length
[01:29:33.041]             list <- base::list
[01:29:33.041]             seq.int <- base::seq.int
[01:29:33.041]             signalCondition <- base::signalCondition
[01:29:33.041]             sys.calls <- base::sys.calls
[01:29:33.041]             `[[` <- base::`[[`
[01:29:33.041]             `+` <- base::`+`
[01:29:33.041]             `<<-` <- base::`<<-`
[01:29:33.041]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:33.041]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:33.041]                   3L)]
[01:29:33.041]             }
[01:29:33.041]             function(cond) {
[01:29:33.041]                 is_error <- inherits(cond, "error")
[01:29:33.041]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:33.041]                   NULL)
[01:29:33.041]                 if (is_error) {
[01:29:33.041]                   sessionInformation <- function() {
[01:29:33.041]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:33.041]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:33.041]                       search = base::search(), system = base::Sys.info())
[01:29:33.041]                   }
[01:29:33.041]                   ...future.conditions[[length(...future.conditions) + 
[01:29:33.041]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:33.041]                     cond$call), session = sessionInformation(), 
[01:29:33.041]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:33.041]                   signalCondition(cond)
[01:29:33.041]                 }
[01:29:33.041]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:33.041]                 "immediateCondition"))) {
[01:29:33.041]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:33.041]                   ...future.conditions[[length(...future.conditions) + 
[01:29:33.041]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:33.041]                   if (TRUE && !signal) {
[01:29:33.041]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.041]                     {
[01:29:33.041]                       inherits <- base::inherits
[01:29:33.041]                       invokeRestart <- base::invokeRestart
[01:29:33.041]                       is.null <- base::is.null
[01:29:33.041]                       muffled <- FALSE
[01:29:33.041]                       if (inherits(cond, "message")) {
[01:29:33.041]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:33.041]                         if (muffled) 
[01:29:33.041]                           invokeRestart("muffleMessage")
[01:29:33.041]                       }
[01:29:33.041]                       else if (inherits(cond, "warning")) {
[01:29:33.041]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:33.041]                         if (muffled) 
[01:29:33.041]                           invokeRestart("muffleWarning")
[01:29:33.041]                       }
[01:29:33.041]                       else if (inherits(cond, "condition")) {
[01:29:33.041]                         if (!is.null(pattern)) {
[01:29:33.041]                           computeRestarts <- base::computeRestarts
[01:29:33.041]                           grepl <- base::grepl
[01:29:33.041]                           restarts <- computeRestarts(cond)
[01:29:33.041]                           for (restart in restarts) {
[01:29:33.041]                             name <- restart$name
[01:29:33.041]                             if (is.null(name)) 
[01:29:33.041]                               next
[01:29:33.041]                             if (!grepl(pattern, name)) 
[01:29:33.041]                               next
[01:29:33.041]                             invokeRestart(restart)
[01:29:33.041]                             muffled <- TRUE
[01:29:33.041]                             break
[01:29:33.041]                           }
[01:29:33.041]                         }
[01:29:33.041]                       }
[01:29:33.041]                       invisible(muffled)
[01:29:33.041]                     }
[01:29:33.041]                     muffleCondition(cond, pattern = "^muffle")
[01:29:33.041]                   }
[01:29:33.041]                 }
[01:29:33.041]                 else {
[01:29:33.041]                   if (TRUE) {
[01:29:33.041]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.041]                     {
[01:29:33.041]                       inherits <- base::inherits
[01:29:33.041]                       invokeRestart <- base::invokeRestart
[01:29:33.041]                       is.null <- base::is.null
[01:29:33.041]                       muffled <- FALSE
[01:29:33.041]                       if (inherits(cond, "message")) {
[01:29:33.041]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:33.041]                         if (muffled) 
[01:29:33.041]                           invokeRestart("muffleMessage")
[01:29:33.041]                       }
[01:29:33.041]                       else if (inherits(cond, "warning")) {
[01:29:33.041]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:33.041]                         if (muffled) 
[01:29:33.041]                           invokeRestart("muffleWarning")
[01:29:33.041]                       }
[01:29:33.041]                       else if (inherits(cond, "condition")) {
[01:29:33.041]                         if (!is.null(pattern)) {
[01:29:33.041]                           computeRestarts <- base::computeRestarts
[01:29:33.041]                           grepl <- base::grepl
[01:29:33.041]                           restarts <- computeRestarts(cond)
[01:29:33.041]                           for (restart in restarts) {
[01:29:33.041]                             name <- restart$name
[01:29:33.041]                             if (is.null(name)) 
[01:29:33.041]                               next
[01:29:33.041]                             if (!grepl(pattern, name)) 
[01:29:33.041]                               next
[01:29:33.041]                             invokeRestart(restart)
[01:29:33.041]                             muffled <- TRUE
[01:29:33.041]                             break
[01:29:33.041]                           }
[01:29:33.041]                         }
[01:29:33.041]                       }
[01:29:33.041]                       invisible(muffled)
[01:29:33.041]                     }
[01:29:33.041]                     muffleCondition(cond, pattern = "^muffle")
[01:29:33.041]                   }
[01:29:33.041]                 }
[01:29:33.041]             }
[01:29:33.041]         }))
[01:29:33.041]     }, error = function(ex) {
[01:29:33.041]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:33.041]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:33.041]                 ...future.rng), started = ...future.startTime, 
[01:29:33.041]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:33.041]             version = "1.8"), class = "FutureResult")
[01:29:33.041]     }, finally = {
[01:29:33.041]         if (!identical(...future.workdir, getwd())) 
[01:29:33.041]             setwd(...future.workdir)
[01:29:33.041]         {
[01:29:33.041]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:33.041]                 ...future.oldOptions$nwarnings <- NULL
[01:29:33.041]             }
[01:29:33.041]             base::options(...future.oldOptions)
[01:29:33.041]             if (.Platform$OS.type == "windows") {
[01:29:33.041]                 old_names <- names(...future.oldEnvVars)
[01:29:33.041]                 envs <- base::Sys.getenv()
[01:29:33.041]                 names <- names(envs)
[01:29:33.041]                 common <- intersect(names, old_names)
[01:29:33.041]                 added <- setdiff(names, old_names)
[01:29:33.041]                 removed <- setdiff(old_names, names)
[01:29:33.041]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:33.041]                   envs[common]]
[01:29:33.041]                 NAMES <- toupper(changed)
[01:29:33.041]                 args <- list()
[01:29:33.041]                 for (kk in seq_along(NAMES)) {
[01:29:33.041]                   name <- changed[[kk]]
[01:29:33.041]                   NAME <- NAMES[[kk]]
[01:29:33.041]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.041]                     next
[01:29:33.041]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:33.041]                 }
[01:29:33.041]                 NAMES <- toupper(added)
[01:29:33.041]                 for (kk in seq_along(NAMES)) {
[01:29:33.041]                   name <- added[[kk]]
[01:29:33.041]                   NAME <- NAMES[[kk]]
[01:29:33.041]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.041]                     next
[01:29:33.041]                   args[[name]] <- ""
[01:29:33.041]                 }
[01:29:33.041]                 NAMES <- toupper(removed)
[01:29:33.041]                 for (kk in seq_along(NAMES)) {
[01:29:33.041]                   name <- removed[[kk]]
[01:29:33.041]                   NAME <- NAMES[[kk]]
[01:29:33.041]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.041]                     next
[01:29:33.041]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:33.041]                 }
[01:29:33.041]                 if (length(args) > 0) 
[01:29:33.041]                   base::do.call(base::Sys.setenv, args = args)
[01:29:33.041]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:33.041]             }
[01:29:33.041]             else {
[01:29:33.041]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:33.041]             }
[01:29:33.041]             {
[01:29:33.041]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:33.041]                   0L) {
[01:29:33.041]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:33.041]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:33.041]                   base::options(opts)
[01:29:33.041]                 }
[01:29:33.041]                 {
[01:29:33.041]                   {
[01:29:33.041]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:33.041]                     NULL
[01:29:33.041]                   }
[01:29:33.041]                   options(future.plan = NULL)
[01:29:33.041]                   if (is.na(NA_character_)) 
[01:29:33.041]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:33.041]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:33.041]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:33.041]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:33.041]                     envir = parent.frame()) 
[01:29:33.041]                   {
[01:29:33.041]                     if (is.function(workers)) 
[01:29:33.041]                       workers <- workers()
[01:29:33.041]                     workers <- structure(as.integer(workers), 
[01:29:33.041]                       class = class(workers))
[01:29:33.041]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:33.041]                       workers >= 1)
[01:29:33.041]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:33.041]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:33.041]                     }
[01:29:33.041]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:33.041]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:33.041]                       envir = envir)
[01:29:33.041]                     if (!future$lazy) 
[01:29:33.041]                       future <- run(future)
[01:29:33.041]                     invisible(future)
[01:29:33.041]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:33.041]                 }
[01:29:33.041]             }
[01:29:33.041]         }
[01:29:33.041]     })
[01:29:33.041]     if (TRUE) {
[01:29:33.041]         base::sink(type = "output", split = FALSE)
[01:29:33.041]         if (TRUE) {
[01:29:33.041]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:33.041]         }
[01:29:33.041]         else {
[01:29:33.041]             ...future.result["stdout"] <- base::list(NULL)
[01:29:33.041]         }
[01:29:33.041]         base::close(...future.stdout)
[01:29:33.041]         ...future.stdout <- NULL
[01:29:33.041]     }
[01:29:33.041]     ...future.result$conditions <- ...future.conditions
[01:29:33.041]     ...future.result$finished <- base::Sys.time()
[01:29:33.041]     ...future.result
[01:29:33.041] }
[01:29:33.046] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:33.065] receiveMessageFromWorker() for ClusterFuture ...
[01:29:33.065] - Validating connection of MultisessionFuture
[01:29:33.066] - received message: FutureResult
[01:29:33.066] - Received FutureResult
[01:29:33.066] - Erased future from FutureRegistry
[01:29:33.066] result() for ClusterFuture ...
[01:29:33.067] - result already collected: FutureResult
[01:29:33.067] result() for ClusterFuture ... done
[01:29:33.067] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:33.067] result() for ClusterFuture ...
[01:29:33.067] - result already collected: FutureResult
[01:29:33.067] result() for ClusterFuture ... done
[01:29:33.068] result() for ClusterFuture ...
[01:29:33.068] - result already collected: FutureResult
[01:29:33.068] result() for ClusterFuture ... done
[01:29:33.069] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:33.069] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:33.070] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:33.070] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:33.071] MultisessionFuture started
[01:29:33.071] - Launch lazy future ... done
[01:29:33.071] run() for 'MultisessionFuture' ... done
[01:29:33.072] getGlobalsAndPackages() ...
[01:29:33.072] Searching for globals...
[01:29:33.073] - globals found: [3] '{', 'sample', 'x'
[01:29:33.074] Searching for globals ... DONE
[01:29:33.074] Resolving globals: FALSE
[01:29:33.074] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:33.075] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:33.075] - globals: [1] 'x'
[01:29:33.075] 
[01:29:33.076] getGlobalsAndPackages() ... DONE
[01:29:33.076] run() for 'Future' ...
[01:29:33.076] - state: 'created'
[01:29:33.077] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:33.093] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:33.093] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:33.094]   - Field: 'node'
[01:29:33.094]   - Field: 'label'
[01:29:33.094]   - Field: 'local'
[01:29:33.094]   - Field: 'owner'
[01:29:33.095]   - Field: 'envir'
[01:29:33.095]   - Field: 'workers'
[01:29:33.095]   - Field: 'packages'
[01:29:33.095]   - Field: 'gc'
[01:29:33.095]   - Field: 'conditions'
[01:29:33.096]   - Field: 'persistent'
[01:29:33.096]   - Field: 'expr'
[01:29:33.096]   - Field: 'uuid'
[01:29:33.096]   - Field: 'seed'
[01:29:33.096]   - Field: 'version'
[01:29:33.097]   - Field: 'result'
[01:29:33.097]   - Field: 'asynchronous'
[01:29:33.097]   - Field: 'calls'
[01:29:33.097]   - Field: 'globals'
[01:29:33.098]   - Field: 'stdout'
[01:29:33.098]   - Field: 'earlySignal'
[01:29:33.098]   - Field: 'lazy'
[01:29:33.098]   - Field: 'state'
[01:29:33.098] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:33.099] - Launch lazy future ...
[01:29:33.099] Packages needed by the future expression (n = 0): <none>
[01:29:33.099] Packages needed by future strategies (n = 0): <none>
[01:29:33.100] {
[01:29:33.100]     {
[01:29:33.100]         {
[01:29:33.100]             ...future.startTime <- base::Sys.time()
[01:29:33.100]             {
[01:29:33.100]                 {
[01:29:33.100]                   {
[01:29:33.100]                     {
[01:29:33.100]                       base::local({
[01:29:33.100]                         has_future <- base::requireNamespace("future", 
[01:29:33.100]                           quietly = TRUE)
[01:29:33.100]                         if (has_future) {
[01:29:33.100]                           ns <- base::getNamespace("future")
[01:29:33.100]                           version <- ns[[".package"]][["version"]]
[01:29:33.100]                           if (is.null(version)) 
[01:29:33.100]                             version <- utils::packageVersion("future")
[01:29:33.100]                         }
[01:29:33.100]                         else {
[01:29:33.100]                           version <- NULL
[01:29:33.100]                         }
[01:29:33.100]                         if (!has_future || version < "1.8.0") {
[01:29:33.100]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:33.100]                             "", base::R.version$version.string), 
[01:29:33.100]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:33.100]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:33.100]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:33.100]                               "release", "version")], collapse = " "), 
[01:29:33.100]                             hostname = base::Sys.info()[["nodename"]])
[01:29:33.100]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:33.100]                             info)
[01:29:33.100]                           info <- base::paste(info, collapse = "; ")
[01:29:33.100]                           if (!has_future) {
[01:29:33.100]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:33.100]                               info)
[01:29:33.100]                           }
[01:29:33.100]                           else {
[01:29:33.100]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:33.100]                               info, version)
[01:29:33.100]                           }
[01:29:33.100]                           base::stop(msg)
[01:29:33.100]                         }
[01:29:33.100]                       })
[01:29:33.100]                     }
[01:29:33.100]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:33.100]                     base::options(mc.cores = 1L)
[01:29:33.100]                   }
[01:29:33.100]                   options(future.plan = NULL)
[01:29:33.100]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:33.100]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:33.100]                 }
[01:29:33.100]                 ...future.workdir <- getwd()
[01:29:33.100]             }
[01:29:33.100]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:33.100]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:33.100]         }
[01:29:33.100]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:33.100]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:33.100]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:33.100]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:33.100]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:33.100]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:33.100]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:33.100]             base::names(...future.oldOptions))
[01:29:33.100]     }
[01:29:33.100]     if (FALSE) {
[01:29:33.100]     }
[01:29:33.100]     else {
[01:29:33.100]         if (TRUE) {
[01:29:33.100]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:33.100]                 open = "w")
[01:29:33.100]         }
[01:29:33.100]         else {
[01:29:33.100]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:33.100]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:33.100]         }
[01:29:33.100]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:33.100]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:33.100]             base::sink(type = "output", split = FALSE)
[01:29:33.100]             base::close(...future.stdout)
[01:29:33.100]         }, add = TRUE)
[01:29:33.100]     }
[01:29:33.100]     ...future.frame <- base::sys.nframe()
[01:29:33.100]     ...future.conditions <- base::list()
[01:29:33.100]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:33.100]     if (FALSE) {
[01:29:33.100]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:33.100]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:33.100]     }
[01:29:33.100]     ...future.result <- base::tryCatch({
[01:29:33.100]         base::withCallingHandlers({
[01:29:33.100]             ...future.value <- base::withVisible(base::local({
[01:29:33.100]                 ...future.makeSendCondition <- base::local({
[01:29:33.100]                   sendCondition <- NULL
[01:29:33.100]                   function(frame = 1L) {
[01:29:33.100]                     if (is.function(sendCondition)) 
[01:29:33.100]                       return(sendCondition)
[01:29:33.100]                     ns <- getNamespace("parallel")
[01:29:33.100]                     if (exists("sendData", mode = "function", 
[01:29:33.100]                       envir = ns)) {
[01:29:33.100]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:33.100]                         envir = ns)
[01:29:33.100]                       envir <- sys.frame(frame)
[01:29:33.100]                       master <- NULL
[01:29:33.100]                       while (!identical(envir, .GlobalEnv) && 
[01:29:33.100]                         !identical(envir, emptyenv())) {
[01:29:33.100]                         if (exists("master", mode = "list", envir = envir, 
[01:29:33.100]                           inherits = FALSE)) {
[01:29:33.100]                           master <- get("master", mode = "list", 
[01:29:33.100]                             envir = envir, inherits = FALSE)
[01:29:33.100]                           if (inherits(master, c("SOCKnode", 
[01:29:33.100]                             "SOCK0node"))) {
[01:29:33.100]                             sendCondition <<- function(cond) {
[01:29:33.100]                               data <- list(type = "VALUE", value = cond, 
[01:29:33.100]                                 success = TRUE)
[01:29:33.100]                               parallel_sendData(master, data)
[01:29:33.100]                             }
[01:29:33.100]                             return(sendCondition)
[01:29:33.100]                           }
[01:29:33.100]                         }
[01:29:33.100]                         frame <- frame + 1L
[01:29:33.100]                         envir <- sys.frame(frame)
[01:29:33.100]                       }
[01:29:33.100]                     }
[01:29:33.100]                     sendCondition <<- function(cond) NULL
[01:29:33.100]                   }
[01:29:33.100]                 })
[01:29:33.100]                 withCallingHandlers({
[01:29:33.100]                   {
[01:29:33.100]                     sample(x, size = 1L)
[01:29:33.100]                   }
[01:29:33.100]                 }, immediateCondition = function(cond) {
[01:29:33.100]                   sendCondition <- ...future.makeSendCondition()
[01:29:33.100]                   sendCondition(cond)
[01:29:33.100]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.100]                   {
[01:29:33.100]                     inherits <- base::inherits
[01:29:33.100]                     invokeRestart <- base::invokeRestart
[01:29:33.100]                     is.null <- base::is.null
[01:29:33.100]                     muffled <- FALSE
[01:29:33.100]                     if (inherits(cond, "message")) {
[01:29:33.100]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:33.100]                       if (muffled) 
[01:29:33.100]                         invokeRestart("muffleMessage")
[01:29:33.100]                     }
[01:29:33.100]                     else if (inherits(cond, "warning")) {
[01:29:33.100]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:33.100]                       if (muffled) 
[01:29:33.100]                         invokeRestart("muffleWarning")
[01:29:33.100]                     }
[01:29:33.100]                     else if (inherits(cond, "condition")) {
[01:29:33.100]                       if (!is.null(pattern)) {
[01:29:33.100]                         computeRestarts <- base::computeRestarts
[01:29:33.100]                         grepl <- base::grepl
[01:29:33.100]                         restarts <- computeRestarts(cond)
[01:29:33.100]                         for (restart in restarts) {
[01:29:33.100]                           name <- restart$name
[01:29:33.100]                           if (is.null(name)) 
[01:29:33.100]                             next
[01:29:33.100]                           if (!grepl(pattern, name)) 
[01:29:33.100]                             next
[01:29:33.100]                           invokeRestart(restart)
[01:29:33.100]                           muffled <- TRUE
[01:29:33.100]                           break
[01:29:33.100]                         }
[01:29:33.100]                       }
[01:29:33.100]                     }
[01:29:33.100]                     invisible(muffled)
[01:29:33.100]                   }
[01:29:33.100]                   muffleCondition(cond)
[01:29:33.100]                 })
[01:29:33.100]             }))
[01:29:33.100]             future::FutureResult(value = ...future.value$value, 
[01:29:33.100]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:33.100]                   ...future.rng), globalenv = if (FALSE) 
[01:29:33.100]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:33.100]                     ...future.globalenv.names))
[01:29:33.100]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:33.100]         }, condition = base::local({
[01:29:33.100]             c <- base::c
[01:29:33.100]             inherits <- base::inherits
[01:29:33.100]             invokeRestart <- base::invokeRestart
[01:29:33.100]             length <- base::length
[01:29:33.100]             list <- base::list
[01:29:33.100]             seq.int <- base::seq.int
[01:29:33.100]             signalCondition <- base::signalCondition
[01:29:33.100]             sys.calls <- base::sys.calls
[01:29:33.100]             `[[` <- base::`[[`
[01:29:33.100]             `+` <- base::`+`
[01:29:33.100]             `<<-` <- base::`<<-`
[01:29:33.100]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:33.100]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:33.100]                   3L)]
[01:29:33.100]             }
[01:29:33.100]             function(cond) {
[01:29:33.100]                 is_error <- inherits(cond, "error")
[01:29:33.100]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:33.100]                   NULL)
[01:29:33.100]                 if (is_error) {
[01:29:33.100]                   sessionInformation <- function() {
[01:29:33.100]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:33.100]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:33.100]                       search = base::search(), system = base::Sys.info())
[01:29:33.100]                   }
[01:29:33.100]                   ...future.conditions[[length(...future.conditions) + 
[01:29:33.100]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:33.100]                     cond$call), session = sessionInformation(), 
[01:29:33.100]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:33.100]                   signalCondition(cond)
[01:29:33.100]                 }
[01:29:33.100]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:33.100]                 "immediateCondition"))) {
[01:29:33.100]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:33.100]                   ...future.conditions[[length(...future.conditions) + 
[01:29:33.100]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:33.100]                   if (TRUE && !signal) {
[01:29:33.100]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.100]                     {
[01:29:33.100]                       inherits <- base::inherits
[01:29:33.100]                       invokeRestart <- base::invokeRestart
[01:29:33.100]                       is.null <- base::is.null
[01:29:33.100]                       muffled <- FALSE
[01:29:33.100]                       if (inherits(cond, "message")) {
[01:29:33.100]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:33.100]                         if (muffled) 
[01:29:33.100]                           invokeRestart("muffleMessage")
[01:29:33.100]                       }
[01:29:33.100]                       else if (inherits(cond, "warning")) {
[01:29:33.100]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:33.100]                         if (muffled) 
[01:29:33.100]                           invokeRestart("muffleWarning")
[01:29:33.100]                       }
[01:29:33.100]                       else if (inherits(cond, "condition")) {
[01:29:33.100]                         if (!is.null(pattern)) {
[01:29:33.100]                           computeRestarts <- base::computeRestarts
[01:29:33.100]                           grepl <- base::grepl
[01:29:33.100]                           restarts <- computeRestarts(cond)
[01:29:33.100]                           for (restart in restarts) {
[01:29:33.100]                             name <- restart$name
[01:29:33.100]                             if (is.null(name)) 
[01:29:33.100]                               next
[01:29:33.100]                             if (!grepl(pattern, name)) 
[01:29:33.100]                               next
[01:29:33.100]                             invokeRestart(restart)
[01:29:33.100]                             muffled <- TRUE
[01:29:33.100]                             break
[01:29:33.100]                           }
[01:29:33.100]                         }
[01:29:33.100]                       }
[01:29:33.100]                       invisible(muffled)
[01:29:33.100]                     }
[01:29:33.100]                     muffleCondition(cond, pattern = "^muffle")
[01:29:33.100]                   }
[01:29:33.100]                 }
[01:29:33.100]                 else {
[01:29:33.100]                   if (TRUE) {
[01:29:33.100]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.100]                     {
[01:29:33.100]                       inherits <- base::inherits
[01:29:33.100]                       invokeRestart <- base::invokeRestart
[01:29:33.100]                       is.null <- base::is.null
[01:29:33.100]                       muffled <- FALSE
[01:29:33.100]                       if (inherits(cond, "message")) {
[01:29:33.100]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:33.100]                         if (muffled) 
[01:29:33.100]                           invokeRestart("muffleMessage")
[01:29:33.100]                       }
[01:29:33.100]                       else if (inherits(cond, "warning")) {
[01:29:33.100]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:33.100]                         if (muffled) 
[01:29:33.100]                           invokeRestart("muffleWarning")
[01:29:33.100]                       }
[01:29:33.100]                       else if (inherits(cond, "condition")) {
[01:29:33.100]                         if (!is.null(pattern)) {
[01:29:33.100]                           computeRestarts <- base::computeRestarts
[01:29:33.100]                           grepl <- base::grepl
[01:29:33.100]                           restarts <- computeRestarts(cond)
[01:29:33.100]                           for (restart in restarts) {
[01:29:33.100]                             name <- restart$name
[01:29:33.100]                             if (is.null(name)) 
[01:29:33.100]                               next
[01:29:33.100]                             if (!grepl(pattern, name)) 
[01:29:33.100]                               next
[01:29:33.100]                             invokeRestart(restart)
[01:29:33.100]                             muffled <- TRUE
[01:29:33.100]                             break
[01:29:33.100]                           }
[01:29:33.100]                         }
[01:29:33.100]                       }
[01:29:33.100]                       invisible(muffled)
[01:29:33.100]                     }
[01:29:33.100]                     muffleCondition(cond, pattern = "^muffle")
[01:29:33.100]                   }
[01:29:33.100]                 }
[01:29:33.100]             }
[01:29:33.100]         }))
[01:29:33.100]     }, error = function(ex) {
[01:29:33.100]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:33.100]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:33.100]                 ...future.rng), started = ...future.startTime, 
[01:29:33.100]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:33.100]             version = "1.8"), class = "FutureResult")
[01:29:33.100]     }, finally = {
[01:29:33.100]         if (!identical(...future.workdir, getwd())) 
[01:29:33.100]             setwd(...future.workdir)
[01:29:33.100]         {
[01:29:33.100]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:33.100]                 ...future.oldOptions$nwarnings <- NULL
[01:29:33.100]             }
[01:29:33.100]             base::options(...future.oldOptions)
[01:29:33.100]             if (.Platform$OS.type == "windows") {
[01:29:33.100]                 old_names <- names(...future.oldEnvVars)
[01:29:33.100]                 envs <- base::Sys.getenv()
[01:29:33.100]                 names <- names(envs)
[01:29:33.100]                 common <- intersect(names, old_names)
[01:29:33.100]                 added <- setdiff(names, old_names)
[01:29:33.100]                 removed <- setdiff(old_names, names)
[01:29:33.100]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:33.100]                   envs[common]]
[01:29:33.100]                 NAMES <- toupper(changed)
[01:29:33.100]                 args <- list()
[01:29:33.100]                 for (kk in seq_along(NAMES)) {
[01:29:33.100]                   name <- changed[[kk]]
[01:29:33.100]                   NAME <- NAMES[[kk]]
[01:29:33.100]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.100]                     next
[01:29:33.100]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:33.100]                 }
[01:29:33.100]                 NAMES <- toupper(added)
[01:29:33.100]                 for (kk in seq_along(NAMES)) {
[01:29:33.100]                   name <- added[[kk]]
[01:29:33.100]                   NAME <- NAMES[[kk]]
[01:29:33.100]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.100]                     next
[01:29:33.100]                   args[[name]] <- ""
[01:29:33.100]                 }
[01:29:33.100]                 NAMES <- toupper(removed)
[01:29:33.100]                 for (kk in seq_along(NAMES)) {
[01:29:33.100]                   name <- removed[[kk]]
[01:29:33.100]                   NAME <- NAMES[[kk]]
[01:29:33.100]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.100]                     next
[01:29:33.100]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:33.100]                 }
[01:29:33.100]                 if (length(args) > 0) 
[01:29:33.100]                   base::do.call(base::Sys.setenv, args = args)
[01:29:33.100]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:33.100]             }
[01:29:33.100]             else {
[01:29:33.100]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:33.100]             }
[01:29:33.100]             {
[01:29:33.100]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:33.100]                   0L) {
[01:29:33.100]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:33.100]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:33.100]                   base::options(opts)
[01:29:33.100]                 }
[01:29:33.100]                 {
[01:29:33.100]                   {
[01:29:33.100]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:33.100]                     NULL
[01:29:33.100]                   }
[01:29:33.100]                   options(future.plan = NULL)
[01:29:33.100]                   if (is.na(NA_character_)) 
[01:29:33.100]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:33.100]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:33.100]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:33.100]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:33.100]                     envir = parent.frame()) 
[01:29:33.100]                   {
[01:29:33.100]                     if (is.function(workers)) 
[01:29:33.100]                       workers <- workers()
[01:29:33.100]                     workers <- structure(as.integer(workers), 
[01:29:33.100]                       class = class(workers))
[01:29:33.100]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:33.100]                       workers >= 1)
[01:29:33.100]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:33.100]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:33.100]                     }
[01:29:33.100]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:33.100]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:33.100]                       envir = envir)
[01:29:33.100]                     if (!future$lazy) 
[01:29:33.100]                       future <- run(future)
[01:29:33.100]                     invisible(future)
[01:29:33.100]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:33.100]                 }
[01:29:33.100]             }
[01:29:33.100]         }
[01:29:33.100]     })
[01:29:33.100]     if (TRUE) {
[01:29:33.100]         base::sink(type = "output", split = FALSE)
[01:29:33.100]         if (TRUE) {
[01:29:33.100]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:33.100]         }
[01:29:33.100]         else {
[01:29:33.100]             ...future.result["stdout"] <- base::list(NULL)
[01:29:33.100]         }
[01:29:33.100]         base::close(...future.stdout)
[01:29:33.100]         ...future.stdout <- NULL
[01:29:33.100]     }
[01:29:33.100]     ...future.result$conditions <- ...future.conditions
[01:29:33.100]     ...future.result$finished <- base::Sys.time()
[01:29:33.100]     ...future.result
[01:29:33.100] }
[01:29:33.106] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:33.128] receiveMessageFromWorker() for ClusterFuture ...
[01:29:33.128] - Validating connection of MultisessionFuture
[01:29:33.129] - received message: FutureResult
[01:29:33.129] - Received FutureResult
[01:29:33.129] - Erased future from FutureRegistry
[01:29:33.129] result() for ClusterFuture ...
[01:29:33.129] - result already collected: FutureResult
[01:29:33.130] result() for ClusterFuture ... done
[01:29:33.130] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:33.130] result() for ClusterFuture ...
[01:29:33.130] - result already collected: FutureResult
[01:29:33.130] result() for ClusterFuture ... done
[01:29:33.131] result() for ClusterFuture ...
[01:29:33.131] - result already collected: FutureResult
[01:29:33.131] result() for ClusterFuture ... done
[01:29:33.132] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:33.132] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:33.133] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:33.133] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:33.134] MultisessionFuture started
[01:29:33.134] - Launch lazy future ... done
[01:29:33.134] run() for 'MultisessionFuture' ... done
[01:29:33.134] result() for ClusterFuture ...
[01:29:33.135] - result already collected: FutureResult
[01:29:33.135] result() for ClusterFuture ... done
[01:29:33.135] result() for ClusterFuture ...
[01:29:33.135] - result already collected: FutureResult
[01:29:33.135] result() for ClusterFuture ... done
[01:29:33.136] signalConditions() ...
[01:29:33.136]  - include = 'immediateCondition'
[01:29:33.136]  - exclude = 
[01:29:33.136]  - resignal = FALSE
[01:29:33.136]  - Number of conditions: 1
[01:29:33.137] signalConditions() ... done
[01:29:33.137] Future state: 'finished'
[01:29:33.137] result() for ClusterFuture ...
[01:29:33.137] - result already collected: FutureResult
[01:29:33.137] result() for ClusterFuture ... done
[01:29:33.137] signalConditions() ...
[01:29:33.138]  - include = 'condition'
[01:29:33.138]  - exclude = 'immediateCondition'
[01:29:33.138]  - resignal = TRUE
[01:29:33.138]  - Number of conditions: 1
[01:29:33.138]  - Condition #1: 'RngFutureError', 'FutureError', 'error', 'RngFutureCondition', 'FutureCondition', 'condition'
[01:29:33.139] signalConditions() ... done
<RngFutureError: UNRELIABLE VALUE: Future ('fsample_1-249481') unexpectedly generated random numbers without specifying argument 'seed'. There is a risk that those random numbers are not statistically sound and the overall results might be invalid. To fix this, specify 'seed=TRUE'. This ensures that proper, parallel-safe random numbers are produced via the L'Ecuyer-CMRG method. To disable this check, use 'seed=NULL', or set option 'future.rng.onMisuse' to "ignore".>


Future UUID: f7e3c4a0-0665-92e2-1fef-113a541b158b


DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
MultisessionFuture:
Label: 'fsample_1-249481'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001b96db19f08
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 64 bytes (integer 'x' of 64 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 56 bytes of class 'integer'
Conditions captured: [n=1] 'RngFutureError'
Early signaling: FALSE
Owner process: 1f1c59e9-d02b-ae13-c084-65f118b81800
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'

DEBUG: END TROUBLESHOOTING HELP
[01:29:33.141] getGlobalsAndPackages() ...
[01:29:33.141] Searching for globals...
[01:29:33.142] - globals found: [3] '{', 'sample', 'x'
[01:29:33.142] Searching for globals ... DONE
[01:29:33.143] Resolving globals: FALSE
[01:29:33.143] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:33.144] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:33.144] - globals: [1] 'x'
[01:29:33.144] 
[01:29:33.144] getGlobalsAndPackages() ... DONE
[01:29:33.145] run() for 'Future' ...
[01:29:33.145] - state: 'created'
[01:29:33.145] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:33.160] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:33.161] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:33.161]   - Field: 'node'
[01:29:33.161]   - Field: 'label'
[01:29:33.161]   - Field: 'local'
[01:29:33.161]   - Field: 'owner'
[01:29:33.161]   - Field: 'envir'
[01:29:33.162]   - Field: 'workers'
[01:29:33.162]   - Field: 'packages'
[01:29:33.162]   - Field: 'gc'
[01:29:33.162]   - Field: 'conditions'
[01:29:33.162]   - Field: 'persistent'
[01:29:33.163]   - Field: 'expr'
[01:29:33.163]   - Field: 'uuid'
[01:29:33.163]   - Field: 'seed'
[01:29:33.163]   - Field: 'version'
[01:29:33.163]   - Field: 'result'
[01:29:33.163]   - Field: 'asynchronous'
[01:29:33.164]   - Field: 'calls'
[01:29:33.164]   - Field: 'globals'
[01:29:33.164]   - Field: 'stdout'
[01:29:33.164]   - Field: 'earlySignal'
[01:29:33.164]   - Field: 'lazy'
[01:29:33.165]   - Field: 'state'
[01:29:33.165] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:33.165] - Launch lazy future ...
[01:29:33.165] Packages needed by the future expression (n = 0): <none>
[01:29:33.166] Packages needed by future strategies (n = 0): <none>
[01:29:33.166] {
[01:29:33.166]     {
[01:29:33.166]         {
[01:29:33.166]             ...future.startTime <- base::Sys.time()
[01:29:33.166]             {
[01:29:33.166]                 {
[01:29:33.166]                   {
[01:29:33.166]                     {
[01:29:33.166]                       base::local({
[01:29:33.166]                         has_future <- base::requireNamespace("future", 
[01:29:33.166]                           quietly = TRUE)
[01:29:33.166]                         if (has_future) {
[01:29:33.166]                           ns <- base::getNamespace("future")
[01:29:33.166]                           version <- ns[[".package"]][["version"]]
[01:29:33.166]                           if (is.null(version)) 
[01:29:33.166]                             version <- utils::packageVersion("future")
[01:29:33.166]                         }
[01:29:33.166]                         else {
[01:29:33.166]                           version <- NULL
[01:29:33.166]                         }
[01:29:33.166]                         if (!has_future || version < "1.8.0") {
[01:29:33.166]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:33.166]                             "", base::R.version$version.string), 
[01:29:33.166]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:33.166]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:33.166]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:33.166]                               "release", "version")], collapse = " "), 
[01:29:33.166]                             hostname = base::Sys.info()[["nodename"]])
[01:29:33.166]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:33.166]                             info)
[01:29:33.166]                           info <- base::paste(info, collapse = "; ")
[01:29:33.166]                           if (!has_future) {
[01:29:33.166]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:33.166]                               info)
[01:29:33.166]                           }
[01:29:33.166]                           else {
[01:29:33.166]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:33.166]                               info, version)
[01:29:33.166]                           }
[01:29:33.166]                           base::stop(msg)
[01:29:33.166]                         }
[01:29:33.166]                       })
[01:29:33.166]                     }
[01:29:33.166]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:33.166]                     base::options(mc.cores = 1L)
[01:29:33.166]                   }
[01:29:33.166]                   options(future.plan = NULL)
[01:29:33.166]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:33.166]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:33.166]                 }
[01:29:33.166]                 ...future.workdir <- getwd()
[01:29:33.166]             }
[01:29:33.166]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:33.166]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:33.166]         }
[01:29:33.166]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:33.166]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:33.166]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:33.166]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:33.166]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:33.166]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:33.166]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:33.166]             base::names(...future.oldOptions))
[01:29:33.166]     }
[01:29:33.166]     if (FALSE) {
[01:29:33.166]     }
[01:29:33.166]     else {
[01:29:33.166]         if (TRUE) {
[01:29:33.166]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:33.166]                 open = "w")
[01:29:33.166]         }
[01:29:33.166]         else {
[01:29:33.166]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:33.166]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:33.166]         }
[01:29:33.166]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:33.166]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:33.166]             base::sink(type = "output", split = FALSE)
[01:29:33.166]             base::close(...future.stdout)
[01:29:33.166]         }, add = TRUE)
[01:29:33.166]     }
[01:29:33.166]     ...future.frame <- base::sys.nframe()
[01:29:33.166]     ...future.conditions <- base::list()
[01:29:33.166]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:33.166]     if (FALSE) {
[01:29:33.166]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:33.166]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:33.166]     }
[01:29:33.166]     ...future.result <- base::tryCatch({
[01:29:33.166]         base::withCallingHandlers({
[01:29:33.166]             ...future.value <- base::withVisible(base::local({
[01:29:33.166]                 ...future.makeSendCondition <- base::local({
[01:29:33.166]                   sendCondition <- NULL
[01:29:33.166]                   function(frame = 1L) {
[01:29:33.166]                     if (is.function(sendCondition)) 
[01:29:33.166]                       return(sendCondition)
[01:29:33.166]                     ns <- getNamespace("parallel")
[01:29:33.166]                     if (exists("sendData", mode = "function", 
[01:29:33.166]                       envir = ns)) {
[01:29:33.166]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:33.166]                         envir = ns)
[01:29:33.166]                       envir <- sys.frame(frame)
[01:29:33.166]                       master <- NULL
[01:29:33.166]                       while (!identical(envir, .GlobalEnv) && 
[01:29:33.166]                         !identical(envir, emptyenv())) {
[01:29:33.166]                         if (exists("master", mode = "list", envir = envir, 
[01:29:33.166]                           inherits = FALSE)) {
[01:29:33.166]                           master <- get("master", mode = "list", 
[01:29:33.166]                             envir = envir, inherits = FALSE)
[01:29:33.166]                           if (inherits(master, c("SOCKnode", 
[01:29:33.166]                             "SOCK0node"))) {
[01:29:33.166]                             sendCondition <<- function(cond) {
[01:29:33.166]                               data <- list(type = "VALUE", value = cond, 
[01:29:33.166]                                 success = TRUE)
[01:29:33.166]                               parallel_sendData(master, data)
[01:29:33.166]                             }
[01:29:33.166]                             return(sendCondition)
[01:29:33.166]                           }
[01:29:33.166]                         }
[01:29:33.166]                         frame <- frame + 1L
[01:29:33.166]                         envir <- sys.frame(frame)
[01:29:33.166]                       }
[01:29:33.166]                     }
[01:29:33.166]                     sendCondition <<- function(cond) NULL
[01:29:33.166]                   }
[01:29:33.166]                 })
[01:29:33.166]                 withCallingHandlers({
[01:29:33.166]                   {
[01:29:33.166]                     sample(x, size = 1L)
[01:29:33.166]                   }
[01:29:33.166]                 }, immediateCondition = function(cond) {
[01:29:33.166]                   sendCondition <- ...future.makeSendCondition()
[01:29:33.166]                   sendCondition(cond)
[01:29:33.166]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.166]                   {
[01:29:33.166]                     inherits <- base::inherits
[01:29:33.166]                     invokeRestart <- base::invokeRestart
[01:29:33.166]                     is.null <- base::is.null
[01:29:33.166]                     muffled <- FALSE
[01:29:33.166]                     if (inherits(cond, "message")) {
[01:29:33.166]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:33.166]                       if (muffled) 
[01:29:33.166]                         invokeRestart("muffleMessage")
[01:29:33.166]                     }
[01:29:33.166]                     else if (inherits(cond, "warning")) {
[01:29:33.166]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:33.166]                       if (muffled) 
[01:29:33.166]                         invokeRestart("muffleWarning")
[01:29:33.166]                     }
[01:29:33.166]                     else if (inherits(cond, "condition")) {
[01:29:33.166]                       if (!is.null(pattern)) {
[01:29:33.166]                         computeRestarts <- base::computeRestarts
[01:29:33.166]                         grepl <- base::grepl
[01:29:33.166]                         restarts <- computeRestarts(cond)
[01:29:33.166]                         for (restart in restarts) {
[01:29:33.166]                           name <- restart$name
[01:29:33.166]                           if (is.null(name)) 
[01:29:33.166]                             next
[01:29:33.166]                           if (!grepl(pattern, name)) 
[01:29:33.166]                             next
[01:29:33.166]                           invokeRestart(restart)
[01:29:33.166]                           muffled <- TRUE
[01:29:33.166]                           break
[01:29:33.166]                         }
[01:29:33.166]                       }
[01:29:33.166]                     }
[01:29:33.166]                     invisible(muffled)
[01:29:33.166]                   }
[01:29:33.166]                   muffleCondition(cond)
[01:29:33.166]                 })
[01:29:33.166]             }))
[01:29:33.166]             future::FutureResult(value = ...future.value$value, 
[01:29:33.166]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:33.166]                   ...future.rng), globalenv = if (FALSE) 
[01:29:33.166]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:33.166]                     ...future.globalenv.names))
[01:29:33.166]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:33.166]         }, condition = base::local({
[01:29:33.166]             c <- base::c
[01:29:33.166]             inherits <- base::inherits
[01:29:33.166]             invokeRestart <- base::invokeRestart
[01:29:33.166]             length <- base::length
[01:29:33.166]             list <- base::list
[01:29:33.166]             seq.int <- base::seq.int
[01:29:33.166]             signalCondition <- base::signalCondition
[01:29:33.166]             sys.calls <- base::sys.calls
[01:29:33.166]             `[[` <- base::`[[`
[01:29:33.166]             `+` <- base::`+`
[01:29:33.166]             `<<-` <- base::`<<-`
[01:29:33.166]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:33.166]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:33.166]                   3L)]
[01:29:33.166]             }
[01:29:33.166]             function(cond) {
[01:29:33.166]                 is_error <- inherits(cond, "error")
[01:29:33.166]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:33.166]                   NULL)
[01:29:33.166]                 if (is_error) {
[01:29:33.166]                   sessionInformation <- function() {
[01:29:33.166]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:33.166]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:33.166]                       search = base::search(), system = base::Sys.info())
[01:29:33.166]                   }
[01:29:33.166]                   ...future.conditions[[length(...future.conditions) + 
[01:29:33.166]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:33.166]                     cond$call), session = sessionInformation(), 
[01:29:33.166]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:33.166]                   signalCondition(cond)
[01:29:33.166]                 }
[01:29:33.166]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:33.166]                 "immediateCondition"))) {
[01:29:33.166]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:33.166]                   ...future.conditions[[length(...future.conditions) + 
[01:29:33.166]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:33.166]                   if (TRUE && !signal) {
[01:29:33.166]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.166]                     {
[01:29:33.166]                       inherits <- base::inherits
[01:29:33.166]                       invokeRestart <- base::invokeRestart
[01:29:33.166]                       is.null <- base::is.null
[01:29:33.166]                       muffled <- FALSE
[01:29:33.166]                       if (inherits(cond, "message")) {
[01:29:33.166]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:33.166]                         if (muffled) 
[01:29:33.166]                           invokeRestart("muffleMessage")
[01:29:33.166]                       }
[01:29:33.166]                       else if (inherits(cond, "warning")) {
[01:29:33.166]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:33.166]                         if (muffled) 
[01:29:33.166]                           invokeRestart("muffleWarning")
[01:29:33.166]                       }
[01:29:33.166]                       else if (inherits(cond, "condition")) {
[01:29:33.166]                         if (!is.null(pattern)) {
[01:29:33.166]                           computeRestarts <- base::computeRestarts
[01:29:33.166]                           grepl <- base::grepl
[01:29:33.166]                           restarts <- computeRestarts(cond)
[01:29:33.166]                           for (restart in restarts) {
[01:29:33.166]                             name <- restart$name
[01:29:33.166]                             if (is.null(name)) 
[01:29:33.166]                               next
[01:29:33.166]                             if (!grepl(pattern, name)) 
[01:29:33.166]                               next
[01:29:33.166]                             invokeRestart(restart)
[01:29:33.166]                             muffled <- TRUE
[01:29:33.166]                             break
[01:29:33.166]                           }
[01:29:33.166]                         }
[01:29:33.166]                       }
[01:29:33.166]                       invisible(muffled)
[01:29:33.166]                     }
[01:29:33.166]                     muffleCondition(cond, pattern = "^muffle")
[01:29:33.166]                   }
[01:29:33.166]                 }
[01:29:33.166]                 else {
[01:29:33.166]                   if (TRUE) {
[01:29:33.166]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.166]                     {
[01:29:33.166]                       inherits <- base::inherits
[01:29:33.166]                       invokeRestart <- base::invokeRestart
[01:29:33.166]                       is.null <- base::is.null
[01:29:33.166]                       muffled <- FALSE
[01:29:33.166]                       if (inherits(cond, "message")) {
[01:29:33.166]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:33.166]                         if (muffled) 
[01:29:33.166]                           invokeRestart("muffleMessage")
[01:29:33.166]                       }
[01:29:33.166]                       else if (inherits(cond, "warning")) {
[01:29:33.166]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:33.166]                         if (muffled) 
[01:29:33.166]                           invokeRestart("muffleWarning")
[01:29:33.166]                       }
[01:29:33.166]                       else if (inherits(cond, "condition")) {
[01:29:33.166]                         if (!is.null(pattern)) {
[01:29:33.166]                           computeRestarts <- base::computeRestarts
[01:29:33.166]                           grepl <- base::grepl
[01:29:33.166]                           restarts <- computeRestarts(cond)
[01:29:33.166]                           for (restart in restarts) {
[01:29:33.166]                             name <- restart$name
[01:29:33.166]                             if (is.null(name)) 
[01:29:33.166]                               next
[01:29:33.166]                             if (!grepl(pattern, name)) 
[01:29:33.166]                               next
[01:29:33.166]                             invokeRestart(restart)
[01:29:33.166]                             muffled <- TRUE
[01:29:33.166]                             break
[01:29:33.166]                           }
[01:29:33.166]                         }
[01:29:33.166]                       }
[01:29:33.166]                       invisible(muffled)
[01:29:33.166]                     }
[01:29:33.166]                     muffleCondition(cond, pattern = "^muffle")
[01:29:33.166]                   }
[01:29:33.166]                 }
[01:29:33.166]             }
[01:29:33.166]         }))
[01:29:33.166]     }, error = function(ex) {
[01:29:33.166]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:33.166]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:33.166]                 ...future.rng), started = ...future.startTime, 
[01:29:33.166]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:33.166]             version = "1.8"), class = "FutureResult")
[01:29:33.166]     }, finally = {
[01:29:33.166]         if (!identical(...future.workdir, getwd())) 
[01:29:33.166]             setwd(...future.workdir)
[01:29:33.166]         {
[01:29:33.166]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:33.166]                 ...future.oldOptions$nwarnings <- NULL
[01:29:33.166]             }
[01:29:33.166]             base::options(...future.oldOptions)
[01:29:33.166]             if (.Platform$OS.type == "windows") {
[01:29:33.166]                 old_names <- names(...future.oldEnvVars)
[01:29:33.166]                 envs <- base::Sys.getenv()
[01:29:33.166]                 names <- names(envs)
[01:29:33.166]                 common <- intersect(names, old_names)
[01:29:33.166]                 added <- setdiff(names, old_names)
[01:29:33.166]                 removed <- setdiff(old_names, names)
[01:29:33.166]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:33.166]                   envs[common]]
[01:29:33.166]                 NAMES <- toupper(changed)
[01:29:33.166]                 args <- list()
[01:29:33.166]                 for (kk in seq_along(NAMES)) {
[01:29:33.166]                   name <- changed[[kk]]
[01:29:33.166]                   NAME <- NAMES[[kk]]
[01:29:33.166]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.166]                     next
[01:29:33.166]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:33.166]                 }
[01:29:33.166]                 NAMES <- toupper(added)
[01:29:33.166]                 for (kk in seq_along(NAMES)) {
[01:29:33.166]                   name <- added[[kk]]
[01:29:33.166]                   NAME <- NAMES[[kk]]
[01:29:33.166]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.166]                     next
[01:29:33.166]                   args[[name]] <- ""
[01:29:33.166]                 }
[01:29:33.166]                 NAMES <- toupper(removed)
[01:29:33.166]                 for (kk in seq_along(NAMES)) {
[01:29:33.166]                   name <- removed[[kk]]
[01:29:33.166]                   NAME <- NAMES[[kk]]
[01:29:33.166]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.166]                     next
[01:29:33.166]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:33.166]                 }
[01:29:33.166]                 if (length(args) > 0) 
[01:29:33.166]                   base::do.call(base::Sys.setenv, args = args)
[01:29:33.166]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:33.166]             }
[01:29:33.166]             else {
[01:29:33.166]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:33.166]             }
[01:29:33.166]             {
[01:29:33.166]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:33.166]                   0L) {
[01:29:33.166]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:33.166]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:33.166]                   base::options(opts)
[01:29:33.166]                 }
[01:29:33.166]                 {
[01:29:33.166]                   {
[01:29:33.166]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:33.166]                     NULL
[01:29:33.166]                   }
[01:29:33.166]                   options(future.plan = NULL)
[01:29:33.166]                   if (is.na(NA_character_)) 
[01:29:33.166]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:33.166]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:33.166]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:33.166]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:33.166]                     envir = parent.frame()) 
[01:29:33.166]                   {
[01:29:33.166]                     if (is.function(workers)) 
[01:29:33.166]                       workers <- workers()
[01:29:33.166]                     workers <- structure(as.integer(workers), 
[01:29:33.166]                       class = class(workers))
[01:29:33.166]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:33.166]                       workers >= 1)
[01:29:33.166]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:33.166]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:33.166]                     }
[01:29:33.166]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:33.166]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:33.166]                       envir = envir)
[01:29:33.166]                     if (!future$lazy) 
[01:29:33.166]                       future <- run(future)
[01:29:33.166]                     invisible(future)
[01:29:33.166]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:33.166]                 }
[01:29:33.166]             }
[01:29:33.166]         }
[01:29:33.166]     })
[01:29:33.166]     if (TRUE) {
[01:29:33.166]         base::sink(type = "output", split = FALSE)
[01:29:33.166]         if (TRUE) {
[01:29:33.166]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:33.166]         }
[01:29:33.166]         else {
[01:29:33.166]             ...future.result["stdout"] <- base::list(NULL)
[01:29:33.166]         }
[01:29:33.166]         base::close(...future.stdout)
[01:29:33.166]         ...future.stdout <- NULL
[01:29:33.166]     }
[01:29:33.166]     ...future.result$conditions <- ...future.conditions
[01:29:33.166]     ...future.result$finished <- base::Sys.time()
[01:29:33.166]     ...future.result
[01:29:33.166] }
[01:29:33.171] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:33.191] receiveMessageFromWorker() for ClusterFuture ...
[01:29:33.192] - Validating connection of MultisessionFuture
[01:29:33.192] - received message: FutureResult
[01:29:33.193] - Received FutureResult
[01:29:33.193] - Erased future from FutureRegistry
[01:29:33.193] result() for ClusterFuture ...
[01:29:33.194] - result already collected: FutureResult
[01:29:33.194] result() for ClusterFuture ... done
[01:29:33.194] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:33.195] result() for ClusterFuture ...
[01:29:33.195] - result already collected: FutureResult
[01:29:33.195] result() for ClusterFuture ... done
[01:29:33.196] result() for ClusterFuture ...
[01:29:33.196] - result already collected: FutureResult
[01:29:33.196] result() for ClusterFuture ... done
[01:29:33.198] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:33.199] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:33.199] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:33.200] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:33.200] MultisessionFuture started
[01:29:33.201] - Launch lazy future ... done
[01:29:33.201] run() for 'MultisessionFuture' ... done
[01:29:33.202] getGlobalsAndPackages() ...
[01:29:33.202] Searching for globals...
[01:29:33.203] - globals found: [3] '{', 'sample', 'x'
[01:29:33.203] Searching for globals ... DONE
[01:29:33.203] Resolving globals: FALSE
[01:29:33.204] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:33.205] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:33.205] - globals: [1] 'x'
[01:29:33.205] 
[01:29:33.205] getGlobalsAndPackages() ... DONE
[01:29:33.206] run() for 'Future' ...
[01:29:33.206] - state: 'created'
[01:29:33.206] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:33.220] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:33.220] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:33.221]   - Field: 'node'
[01:29:33.221]   - Field: 'label'
[01:29:33.221]   - Field: 'local'
[01:29:33.221]   - Field: 'owner'
[01:29:33.222]   - Field: 'envir'
[01:29:33.222]   - Field: 'workers'
[01:29:33.222]   - Field: 'packages'
[01:29:33.222]   - Field: 'gc'
[01:29:33.222]   - Field: 'conditions'
[01:29:33.222]   - Field: 'persistent'
[01:29:33.223]   - Field: 'expr'
[01:29:33.223]   - Field: 'uuid'
[01:29:33.223]   - Field: 'seed'
[01:29:33.223]   - Field: 'version'
[01:29:33.223]   - Field: 'result'
[01:29:33.224]   - Field: 'asynchronous'
[01:29:33.224]   - Field: 'calls'
[01:29:33.224]   - Field: 'globals'
[01:29:33.224]   - Field: 'stdout'
[01:29:33.224]   - Field: 'earlySignal'
[01:29:33.224]   - Field: 'lazy'
[01:29:33.225]   - Field: 'state'
[01:29:33.229] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:33.229] - Launch lazy future ...
[01:29:33.230] Packages needed by the future expression (n = 0): <none>
[01:29:33.230] Packages needed by future strategies (n = 0): <none>
[01:29:33.231] {
[01:29:33.231]     {
[01:29:33.231]         {
[01:29:33.231]             ...future.startTime <- base::Sys.time()
[01:29:33.231]             {
[01:29:33.231]                 {
[01:29:33.231]                   {
[01:29:33.231]                     {
[01:29:33.231]                       base::local({
[01:29:33.231]                         has_future <- base::requireNamespace("future", 
[01:29:33.231]                           quietly = TRUE)
[01:29:33.231]                         if (has_future) {
[01:29:33.231]                           ns <- base::getNamespace("future")
[01:29:33.231]                           version <- ns[[".package"]][["version"]]
[01:29:33.231]                           if (is.null(version)) 
[01:29:33.231]                             version <- utils::packageVersion("future")
[01:29:33.231]                         }
[01:29:33.231]                         else {
[01:29:33.231]                           version <- NULL
[01:29:33.231]                         }
[01:29:33.231]                         if (!has_future || version < "1.8.0") {
[01:29:33.231]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:33.231]                             "", base::R.version$version.string), 
[01:29:33.231]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:33.231]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:33.231]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:33.231]                               "release", "version")], collapse = " "), 
[01:29:33.231]                             hostname = base::Sys.info()[["nodename"]])
[01:29:33.231]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:33.231]                             info)
[01:29:33.231]                           info <- base::paste(info, collapse = "; ")
[01:29:33.231]                           if (!has_future) {
[01:29:33.231]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:33.231]                               info)
[01:29:33.231]                           }
[01:29:33.231]                           else {
[01:29:33.231]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:33.231]                               info, version)
[01:29:33.231]                           }
[01:29:33.231]                           base::stop(msg)
[01:29:33.231]                         }
[01:29:33.231]                       })
[01:29:33.231]                     }
[01:29:33.231]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:33.231]                     base::options(mc.cores = 1L)
[01:29:33.231]                   }
[01:29:33.231]                   options(future.plan = NULL)
[01:29:33.231]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:33.231]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:33.231]                 }
[01:29:33.231]                 ...future.workdir <- getwd()
[01:29:33.231]             }
[01:29:33.231]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:33.231]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:33.231]         }
[01:29:33.231]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:33.231]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:33.231]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:33.231]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:33.231]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:33.231]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:33.231]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:33.231]             base::names(...future.oldOptions))
[01:29:33.231]     }
[01:29:33.231]     if (FALSE) {
[01:29:33.231]     }
[01:29:33.231]     else {
[01:29:33.231]         if (TRUE) {
[01:29:33.231]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:33.231]                 open = "w")
[01:29:33.231]         }
[01:29:33.231]         else {
[01:29:33.231]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:33.231]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:33.231]         }
[01:29:33.231]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:33.231]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:33.231]             base::sink(type = "output", split = FALSE)
[01:29:33.231]             base::close(...future.stdout)
[01:29:33.231]         }, add = TRUE)
[01:29:33.231]     }
[01:29:33.231]     ...future.frame <- base::sys.nframe()
[01:29:33.231]     ...future.conditions <- base::list()
[01:29:33.231]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:33.231]     if (FALSE) {
[01:29:33.231]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:33.231]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:33.231]     }
[01:29:33.231]     ...future.result <- base::tryCatch({
[01:29:33.231]         base::withCallingHandlers({
[01:29:33.231]             ...future.value <- base::withVisible(base::local({
[01:29:33.231]                 ...future.makeSendCondition <- base::local({
[01:29:33.231]                   sendCondition <- NULL
[01:29:33.231]                   function(frame = 1L) {
[01:29:33.231]                     if (is.function(sendCondition)) 
[01:29:33.231]                       return(sendCondition)
[01:29:33.231]                     ns <- getNamespace("parallel")
[01:29:33.231]                     if (exists("sendData", mode = "function", 
[01:29:33.231]                       envir = ns)) {
[01:29:33.231]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:33.231]                         envir = ns)
[01:29:33.231]                       envir <- sys.frame(frame)
[01:29:33.231]                       master <- NULL
[01:29:33.231]                       while (!identical(envir, .GlobalEnv) && 
[01:29:33.231]                         !identical(envir, emptyenv())) {
[01:29:33.231]                         if (exists("master", mode = "list", envir = envir, 
[01:29:33.231]                           inherits = FALSE)) {
[01:29:33.231]                           master <- get("master", mode = "list", 
[01:29:33.231]                             envir = envir, inherits = FALSE)
[01:29:33.231]                           if (inherits(master, c("SOCKnode", 
[01:29:33.231]                             "SOCK0node"))) {
[01:29:33.231]                             sendCondition <<- function(cond) {
[01:29:33.231]                               data <- list(type = "VALUE", value = cond, 
[01:29:33.231]                                 success = TRUE)
[01:29:33.231]                               parallel_sendData(master, data)
[01:29:33.231]                             }
[01:29:33.231]                             return(sendCondition)
[01:29:33.231]                           }
[01:29:33.231]                         }
[01:29:33.231]                         frame <- frame + 1L
[01:29:33.231]                         envir <- sys.frame(frame)
[01:29:33.231]                       }
[01:29:33.231]                     }
[01:29:33.231]                     sendCondition <<- function(cond) NULL
[01:29:33.231]                   }
[01:29:33.231]                 })
[01:29:33.231]                 withCallingHandlers({
[01:29:33.231]                   {
[01:29:33.231]                     sample(x, size = 1L)
[01:29:33.231]                   }
[01:29:33.231]                 }, immediateCondition = function(cond) {
[01:29:33.231]                   sendCondition <- ...future.makeSendCondition()
[01:29:33.231]                   sendCondition(cond)
[01:29:33.231]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.231]                   {
[01:29:33.231]                     inherits <- base::inherits
[01:29:33.231]                     invokeRestart <- base::invokeRestart
[01:29:33.231]                     is.null <- base::is.null
[01:29:33.231]                     muffled <- FALSE
[01:29:33.231]                     if (inherits(cond, "message")) {
[01:29:33.231]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:33.231]                       if (muffled) 
[01:29:33.231]                         invokeRestart("muffleMessage")
[01:29:33.231]                     }
[01:29:33.231]                     else if (inherits(cond, "warning")) {
[01:29:33.231]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:33.231]                       if (muffled) 
[01:29:33.231]                         invokeRestart("muffleWarning")
[01:29:33.231]                     }
[01:29:33.231]                     else if (inherits(cond, "condition")) {
[01:29:33.231]                       if (!is.null(pattern)) {
[01:29:33.231]                         computeRestarts <- base::computeRestarts
[01:29:33.231]                         grepl <- base::grepl
[01:29:33.231]                         restarts <- computeRestarts(cond)
[01:29:33.231]                         for (restart in restarts) {
[01:29:33.231]                           name <- restart$name
[01:29:33.231]                           if (is.null(name)) 
[01:29:33.231]                             next
[01:29:33.231]                           if (!grepl(pattern, name)) 
[01:29:33.231]                             next
[01:29:33.231]                           invokeRestart(restart)
[01:29:33.231]                           muffled <- TRUE
[01:29:33.231]                           break
[01:29:33.231]                         }
[01:29:33.231]                       }
[01:29:33.231]                     }
[01:29:33.231]                     invisible(muffled)
[01:29:33.231]                   }
[01:29:33.231]                   muffleCondition(cond)
[01:29:33.231]                 })
[01:29:33.231]             }))
[01:29:33.231]             future::FutureResult(value = ...future.value$value, 
[01:29:33.231]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:33.231]                   ...future.rng), globalenv = if (FALSE) 
[01:29:33.231]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:33.231]                     ...future.globalenv.names))
[01:29:33.231]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:33.231]         }, condition = base::local({
[01:29:33.231]             c <- base::c
[01:29:33.231]             inherits <- base::inherits
[01:29:33.231]             invokeRestart <- base::invokeRestart
[01:29:33.231]             length <- base::length
[01:29:33.231]             list <- base::list
[01:29:33.231]             seq.int <- base::seq.int
[01:29:33.231]             signalCondition <- base::signalCondition
[01:29:33.231]             sys.calls <- base::sys.calls
[01:29:33.231]             `[[` <- base::`[[`
[01:29:33.231]             `+` <- base::`+`
[01:29:33.231]             `<<-` <- base::`<<-`
[01:29:33.231]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:33.231]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:33.231]                   3L)]
[01:29:33.231]             }
[01:29:33.231]             function(cond) {
[01:29:33.231]                 is_error <- inherits(cond, "error")
[01:29:33.231]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:33.231]                   NULL)
[01:29:33.231]                 if (is_error) {
[01:29:33.231]                   sessionInformation <- function() {
[01:29:33.231]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:33.231]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:33.231]                       search = base::search(), system = base::Sys.info())
[01:29:33.231]                   }
[01:29:33.231]                   ...future.conditions[[length(...future.conditions) + 
[01:29:33.231]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:33.231]                     cond$call), session = sessionInformation(), 
[01:29:33.231]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:33.231]                   signalCondition(cond)
[01:29:33.231]                 }
[01:29:33.231]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:33.231]                 "immediateCondition"))) {
[01:29:33.231]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:33.231]                   ...future.conditions[[length(...future.conditions) + 
[01:29:33.231]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:33.231]                   if (TRUE && !signal) {
[01:29:33.231]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.231]                     {
[01:29:33.231]                       inherits <- base::inherits
[01:29:33.231]                       invokeRestart <- base::invokeRestart
[01:29:33.231]                       is.null <- base::is.null
[01:29:33.231]                       muffled <- FALSE
[01:29:33.231]                       if (inherits(cond, "message")) {
[01:29:33.231]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:33.231]                         if (muffled) 
[01:29:33.231]                           invokeRestart("muffleMessage")
[01:29:33.231]                       }
[01:29:33.231]                       else if (inherits(cond, "warning")) {
[01:29:33.231]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:33.231]                         if (muffled) 
[01:29:33.231]                           invokeRestart("muffleWarning")
[01:29:33.231]                       }
[01:29:33.231]                       else if (inherits(cond, "condition")) {
[01:29:33.231]                         if (!is.null(pattern)) {
[01:29:33.231]                           computeRestarts <- base::computeRestarts
[01:29:33.231]                           grepl <- base::grepl
[01:29:33.231]                           restarts <- computeRestarts(cond)
[01:29:33.231]                           for (restart in restarts) {
[01:29:33.231]                             name <- restart$name
[01:29:33.231]                             if (is.null(name)) 
[01:29:33.231]                               next
[01:29:33.231]                             if (!grepl(pattern, name)) 
[01:29:33.231]                               next
[01:29:33.231]                             invokeRestart(restart)
[01:29:33.231]                             muffled <- TRUE
[01:29:33.231]                             break
[01:29:33.231]                           }
[01:29:33.231]                         }
[01:29:33.231]                       }
[01:29:33.231]                       invisible(muffled)
[01:29:33.231]                     }
[01:29:33.231]                     muffleCondition(cond, pattern = "^muffle")
[01:29:33.231]                   }
[01:29:33.231]                 }
[01:29:33.231]                 else {
[01:29:33.231]                   if (TRUE) {
[01:29:33.231]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.231]                     {
[01:29:33.231]                       inherits <- base::inherits
[01:29:33.231]                       invokeRestart <- base::invokeRestart
[01:29:33.231]                       is.null <- base::is.null
[01:29:33.231]                       muffled <- FALSE
[01:29:33.231]                       if (inherits(cond, "message")) {
[01:29:33.231]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:33.231]                         if (muffled) 
[01:29:33.231]                           invokeRestart("muffleMessage")
[01:29:33.231]                       }
[01:29:33.231]                       else if (inherits(cond, "warning")) {
[01:29:33.231]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:33.231]                         if (muffled) 
[01:29:33.231]                           invokeRestart("muffleWarning")
[01:29:33.231]                       }
[01:29:33.231]                       else if (inherits(cond, "condition")) {
[01:29:33.231]                         if (!is.null(pattern)) {
[01:29:33.231]                           computeRestarts <- base::computeRestarts
[01:29:33.231]                           grepl <- base::grepl
[01:29:33.231]                           restarts <- computeRestarts(cond)
[01:29:33.231]                           for (restart in restarts) {
[01:29:33.231]                             name <- restart$name
[01:29:33.231]                             if (is.null(name)) 
[01:29:33.231]                               next
[01:29:33.231]                             if (!grepl(pattern, name)) 
[01:29:33.231]                               next
[01:29:33.231]                             invokeRestart(restart)
[01:29:33.231]                             muffled <- TRUE
[01:29:33.231]                             break
[01:29:33.231]                           }
[01:29:33.231]                         }
[01:29:33.231]                       }
[01:29:33.231]                       invisible(muffled)
[01:29:33.231]                     }
[01:29:33.231]                     muffleCondition(cond, pattern = "^muffle")
[01:29:33.231]                   }
[01:29:33.231]                 }
[01:29:33.231]             }
[01:29:33.231]         }))
[01:29:33.231]     }, error = function(ex) {
[01:29:33.231]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:33.231]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:33.231]                 ...future.rng), started = ...future.startTime, 
[01:29:33.231]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:33.231]             version = "1.8"), class = "FutureResult")
[01:29:33.231]     }, finally = {
[01:29:33.231]         if (!identical(...future.workdir, getwd())) 
[01:29:33.231]             setwd(...future.workdir)
[01:29:33.231]         {
[01:29:33.231]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:33.231]                 ...future.oldOptions$nwarnings <- NULL
[01:29:33.231]             }
[01:29:33.231]             base::options(...future.oldOptions)
[01:29:33.231]             if (.Platform$OS.type == "windows") {
[01:29:33.231]                 old_names <- names(...future.oldEnvVars)
[01:29:33.231]                 envs <- base::Sys.getenv()
[01:29:33.231]                 names <- names(envs)
[01:29:33.231]                 common <- intersect(names, old_names)
[01:29:33.231]                 added <- setdiff(names, old_names)
[01:29:33.231]                 removed <- setdiff(old_names, names)
[01:29:33.231]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:33.231]                   envs[common]]
[01:29:33.231]                 NAMES <- toupper(changed)
[01:29:33.231]                 args <- list()
[01:29:33.231]                 for (kk in seq_along(NAMES)) {
[01:29:33.231]                   name <- changed[[kk]]
[01:29:33.231]                   NAME <- NAMES[[kk]]
[01:29:33.231]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.231]                     next
[01:29:33.231]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:33.231]                 }
[01:29:33.231]                 NAMES <- toupper(added)
[01:29:33.231]                 for (kk in seq_along(NAMES)) {
[01:29:33.231]                   name <- added[[kk]]
[01:29:33.231]                   NAME <- NAMES[[kk]]
[01:29:33.231]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.231]                     next
[01:29:33.231]                   args[[name]] <- ""
[01:29:33.231]                 }
[01:29:33.231]                 NAMES <- toupper(removed)
[01:29:33.231]                 for (kk in seq_along(NAMES)) {
[01:29:33.231]                   name <- removed[[kk]]
[01:29:33.231]                   NAME <- NAMES[[kk]]
[01:29:33.231]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.231]                     next
[01:29:33.231]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:33.231]                 }
[01:29:33.231]                 if (length(args) > 0) 
[01:29:33.231]                   base::do.call(base::Sys.setenv, args = args)
[01:29:33.231]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:33.231]             }
[01:29:33.231]             else {
[01:29:33.231]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:33.231]             }
[01:29:33.231]             {
[01:29:33.231]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:33.231]                   0L) {
[01:29:33.231]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:33.231]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:33.231]                   base::options(opts)
[01:29:33.231]                 }
[01:29:33.231]                 {
[01:29:33.231]                   {
[01:29:33.231]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:33.231]                     NULL
[01:29:33.231]                   }
[01:29:33.231]                   options(future.plan = NULL)
[01:29:33.231]                   if (is.na(NA_character_)) 
[01:29:33.231]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:33.231]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:33.231]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:33.231]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:33.231]                     envir = parent.frame()) 
[01:29:33.231]                   {
[01:29:33.231]                     if (is.function(workers)) 
[01:29:33.231]                       workers <- workers()
[01:29:33.231]                     workers <- structure(as.integer(workers), 
[01:29:33.231]                       class = class(workers))
[01:29:33.231]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:33.231]                       workers >= 1)
[01:29:33.231]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:33.231]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:33.231]                     }
[01:29:33.231]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:33.231]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:33.231]                       envir = envir)
[01:29:33.231]                     if (!future$lazy) 
[01:29:33.231]                       future <- run(future)
[01:29:33.231]                     invisible(future)
[01:29:33.231]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:33.231]                 }
[01:29:33.231]             }
[01:29:33.231]         }
[01:29:33.231]     })
[01:29:33.231]     if (TRUE) {
[01:29:33.231]         base::sink(type = "output", split = FALSE)
[01:29:33.231]         if (TRUE) {
[01:29:33.231]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:33.231]         }
[01:29:33.231]         else {
[01:29:33.231]             ...future.result["stdout"] <- base::list(NULL)
[01:29:33.231]         }
[01:29:33.231]         base::close(...future.stdout)
[01:29:33.231]         ...future.stdout <- NULL
[01:29:33.231]     }
[01:29:33.231]     ...future.result$conditions <- ...future.conditions
[01:29:33.231]     ...future.result$finished <- base::Sys.time()
[01:29:33.231]     ...future.result
[01:29:33.231] }
[01:29:33.236] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:33.253] receiveMessageFromWorker() for ClusterFuture ...
[01:29:33.253] - Validating connection of MultisessionFuture
[01:29:33.254] - received message: FutureResult
[01:29:33.254] - Received FutureResult
[01:29:33.254] - Erased future from FutureRegistry
[01:29:33.255] result() for ClusterFuture ...
[01:29:33.255] - result already collected: FutureResult
[01:29:33.255] result() for ClusterFuture ... done
[01:29:33.255] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:33.255] result() for ClusterFuture ...
[01:29:33.256] - result already collected: FutureResult
[01:29:33.256] result() for ClusterFuture ... done
[01:29:33.256] result() for ClusterFuture ...
[01:29:33.256] - result already collected: FutureResult
[01:29:33.256] result() for ClusterFuture ... done
[01:29:33.258] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:33.258] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:33.259] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:33.259] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:33.260] MultisessionFuture started
[01:29:33.260] - Launch lazy future ... done
[01:29:33.260] run() for 'MultisessionFuture' ... done
[01:29:33.261] getGlobalsAndPackages() ...
[01:29:33.261] Searching for globals...
[01:29:33.262] - globals found: [3] '{', 'sample', 'x'
[01:29:33.263] Searching for globals ... DONE
[01:29:33.263] Resolving globals: FALSE
[01:29:33.263] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:33.264] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:33.264] - globals: [1] 'x'
[01:29:33.264] 
[01:29:33.265] getGlobalsAndPackages() ... DONE
[01:29:33.265] run() for 'Future' ...
[01:29:33.265] - state: 'created'
[01:29:33.265] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:33.280] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:33.280] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:33.280]   - Field: 'node'
[01:29:33.280]   - Field: 'label'
[01:29:33.281]   - Field: 'local'
[01:29:33.281]   - Field: 'owner'
[01:29:33.281]   - Field: 'envir'
[01:29:33.281]   - Field: 'workers'
[01:29:33.281]   - Field: 'packages'
[01:29:33.282]   - Field: 'gc'
[01:29:33.282]   - Field: 'conditions'
[01:29:33.282]   - Field: 'persistent'
[01:29:33.282]   - Field: 'expr'
[01:29:33.282]   - Field: 'uuid'
[01:29:33.282]   - Field: 'seed'
[01:29:33.283]   - Field: 'version'
[01:29:33.283]   - Field: 'result'
[01:29:33.283]   - Field: 'asynchronous'
[01:29:33.283]   - Field: 'calls'
[01:29:33.283]   - Field: 'globals'
[01:29:33.284]   - Field: 'stdout'
[01:29:33.284]   - Field: 'earlySignal'
[01:29:33.284]   - Field: 'lazy'
[01:29:33.284]   - Field: 'state'
[01:29:33.284] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:33.285] - Launch lazy future ...
[01:29:33.285] Packages needed by the future expression (n = 0): <none>
[01:29:33.285] Packages needed by future strategies (n = 0): <none>
[01:29:33.286] {
[01:29:33.286]     {
[01:29:33.286]         {
[01:29:33.286]             ...future.startTime <- base::Sys.time()
[01:29:33.286]             {
[01:29:33.286]                 {
[01:29:33.286]                   {
[01:29:33.286]                     {
[01:29:33.286]                       base::local({
[01:29:33.286]                         has_future <- base::requireNamespace("future", 
[01:29:33.286]                           quietly = TRUE)
[01:29:33.286]                         if (has_future) {
[01:29:33.286]                           ns <- base::getNamespace("future")
[01:29:33.286]                           version <- ns[[".package"]][["version"]]
[01:29:33.286]                           if (is.null(version)) 
[01:29:33.286]                             version <- utils::packageVersion("future")
[01:29:33.286]                         }
[01:29:33.286]                         else {
[01:29:33.286]                           version <- NULL
[01:29:33.286]                         }
[01:29:33.286]                         if (!has_future || version < "1.8.0") {
[01:29:33.286]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:33.286]                             "", base::R.version$version.string), 
[01:29:33.286]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:33.286]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:33.286]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:33.286]                               "release", "version")], collapse = " "), 
[01:29:33.286]                             hostname = base::Sys.info()[["nodename"]])
[01:29:33.286]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:33.286]                             info)
[01:29:33.286]                           info <- base::paste(info, collapse = "; ")
[01:29:33.286]                           if (!has_future) {
[01:29:33.286]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:33.286]                               info)
[01:29:33.286]                           }
[01:29:33.286]                           else {
[01:29:33.286]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:33.286]                               info, version)
[01:29:33.286]                           }
[01:29:33.286]                           base::stop(msg)
[01:29:33.286]                         }
[01:29:33.286]                       })
[01:29:33.286]                     }
[01:29:33.286]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:33.286]                     base::options(mc.cores = 1L)
[01:29:33.286]                   }
[01:29:33.286]                   options(future.plan = NULL)
[01:29:33.286]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:33.286]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:33.286]                 }
[01:29:33.286]                 ...future.workdir <- getwd()
[01:29:33.286]             }
[01:29:33.286]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:33.286]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:33.286]         }
[01:29:33.286]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:33.286]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:33.286]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:33.286]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:33.286]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:33.286]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:33.286]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:33.286]             base::names(...future.oldOptions))
[01:29:33.286]     }
[01:29:33.286]     if (FALSE) {
[01:29:33.286]     }
[01:29:33.286]     else {
[01:29:33.286]         if (TRUE) {
[01:29:33.286]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:33.286]                 open = "w")
[01:29:33.286]         }
[01:29:33.286]         else {
[01:29:33.286]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:33.286]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:33.286]         }
[01:29:33.286]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:33.286]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:33.286]             base::sink(type = "output", split = FALSE)
[01:29:33.286]             base::close(...future.stdout)
[01:29:33.286]         }, add = TRUE)
[01:29:33.286]     }
[01:29:33.286]     ...future.frame <- base::sys.nframe()
[01:29:33.286]     ...future.conditions <- base::list()
[01:29:33.286]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:33.286]     if (FALSE) {
[01:29:33.286]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:33.286]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:33.286]     }
[01:29:33.286]     ...future.result <- base::tryCatch({
[01:29:33.286]         base::withCallingHandlers({
[01:29:33.286]             ...future.value <- base::withVisible(base::local({
[01:29:33.286]                 ...future.makeSendCondition <- base::local({
[01:29:33.286]                   sendCondition <- NULL
[01:29:33.286]                   function(frame = 1L) {
[01:29:33.286]                     if (is.function(sendCondition)) 
[01:29:33.286]                       return(sendCondition)
[01:29:33.286]                     ns <- getNamespace("parallel")
[01:29:33.286]                     if (exists("sendData", mode = "function", 
[01:29:33.286]                       envir = ns)) {
[01:29:33.286]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:33.286]                         envir = ns)
[01:29:33.286]                       envir <- sys.frame(frame)
[01:29:33.286]                       master <- NULL
[01:29:33.286]                       while (!identical(envir, .GlobalEnv) && 
[01:29:33.286]                         !identical(envir, emptyenv())) {
[01:29:33.286]                         if (exists("master", mode = "list", envir = envir, 
[01:29:33.286]                           inherits = FALSE)) {
[01:29:33.286]                           master <- get("master", mode = "list", 
[01:29:33.286]                             envir = envir, inherits = FALSE)
[01:29:33.286]                           if (inherits(master, c("SOCKnode", 
[01:29:33.286]                             "SOCK0node"))) {
[01:29:33.286]                             sendCondition <<- function(cond) {
[01:29:33.286]                               data <- list(type = "VALUE", value = cond, 
[01:29:33.286]                                 success = TRUE)
[01:29:33.286]                               parallel_sendData(master, data)
[01:29:33.286]                             }
[01:29:33.286]                             return(sendCondition)
[01:29:33.286]                           }
[01:29:33.286]                         }
[01:29:33.286]                         frame <- frame + 1L
[01:29:33.286]                         envir <- sys.frame(frame)
[01:29:33.286]                       }
[01:29:33.286]                     }
[01:29:33.286]                     sendCondition <<- function(cond) NULL
[01:29:33.286]                   }
[01:29:33.286]                 })
[01:29:33.286]                 withCallingHandlers({
[01:29:33.286]                   {
[01:29:33.286]                     sample(x, size = 1L)
[01:29:33.286]                   }
[01:29:33.286]                 }, immediateCondition = function(cond) {
[01:29:33.286]                   sendCondition <- ...future.makeSendCondition()
[01:29:33.286]                   sendCondition(cond)
[01:29:33.286]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.286]                   {
[01:29:33.286]                     inherits <- base::inherits
[01:29:33.286]                     invokeRestart <- base::invokeRestart
[01:29:33.286]                     is.null <- base::is.null
[01:29:33.286]                     muffled <- FALSE
[01:29:33.286]                     if (inherits(cond, "message")) {
[01:29:33.286]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:33.286]                       if (muffled) 
[01:29:33.286]                         invokeRestart("muffleMessage")
[01:29:33.286]                     }
[01:29:33.286]                     else if (inherits(cond, "warning")) {
[01:29:33.286]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:33.286]                       if (muffled) 
[01:29:33.286]                         invokeRestart("muffleWarning")
[01:29:33.286]                     }
[01:29:33.286]                     else if (inherits(cond, "condition")) {
[01:29:33.286]                       if (!is.null(pattern)) {
[01:29:33.286]                         computeRestarts <- base::computeRestarts
[01:29:33.286]                         grepl <- base::grepl
[01:29:33.286]                         restarts <- computeRestarts(cond)
[01:29:33.286]                         for (restart in restarts) {
[01:29:33.286]                           name <- restart$name
[01:29:33.286]                           if (is.null(name)) 
[01:29:33.286]                             next
[01:29:33.286]                           if (!grepl(pattern, name)) 
[01:29:33.286]                             next
[01:29:33.286]                           invokeRestart(restart)
[01:29:33.286]                           muffled <- TRUE
[01:29:33.286]                           break
[01:29:33.286]                         }
[01:29:33.286]                       }
[01:29:33.286]                     }
[01:29:33.286]                     invisible(muffled)
[01:29:33.286]                   }
[01:29:33.286]                   muffleCondition(cond)
[01:29:33.286]                 })
[01:29:33.286]             }))
[01:29:33.286]             future::FutureResult(value = ...future.value$value, 
[01:29:33.286]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:33.286]                   ...future.rng), globalenv = if (FALSE) 
[01:29:33.286]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:33.286]                     ...future.globalenv.names))
[01:29:33.286]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:33.286]         }, condition = base::local({
[01:29:33.286]             c <- base::c
[01:29:33.286]             inherits <- base::inherits
[01:29:33.286]             invokeRestart <- base::invokeRestart
[01:29:33.286]             length <- base::length
[01:29:33.286]             list <- base::list
[01:29:33.286]             seq.int <- base::seq.int
[01:29:33.286]             signalCondition <- base::signalCondition
[01:29:33.286]             sys.calls <- base::sys.calls
[01:29:33.286]             `[[` <- base::`[[`
[01:29:33.286]             `+` <- base::`+`
[01:29:33.286]             `<<-` <- base::`<<-`
[01:29:33.286]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:33.286]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:33.286]                   3L)]
[01:29:33.286]             }
[01:29:33.286]             function(cond) {
[01:29:33.286]                 is_error <- inherits(cond, "error")
[01:29:33.286]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:33.286]                   NULL)
[01:29:33.286]                 if (is_error) {
[01:29:33.286]                   sessionInformation <- function() {
[01:29:33.286]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:33.286]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:33.286]                       search = base::search(), system = base::Sys.info())
[01:29:33.286]                   }
[01:29:33.286]                   ...future.conditions[[length(...future.conditions) + 
[01:29:33.286]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:33.286]                     cond$call), session = sessionInformation(), 
[01:29:33.286]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:33.286]                   signalCondition(cond)
[01:29:33.286]                 }
[01:29:33.286]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:33.286]                 "immediateCondition"))) {
[01:29:33.286]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:33.286]                   ...future.conditions[[length(...future.conditions) + 
[01:29:33.286]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:33.286]                   if (TRUE && !signal) {
[01:29:33.286]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.286]                     {
[01:29:33.286]                       inherits <- base::inherits
[01:29:33.286]                       invokeRestart <- base::invokeRestart
[01:29:33.286]                       is.null <- base::is.null
[01:29:33.286]                       muffled <- FALSE
[01:29:33.286]                       if (inherits(cond, "message")) {
[01:29:33.286]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:33.286]                         if (muffled) 
[01:29:33.286]                           invokeRestart("muffleMessage")
[01:29:33.286]                       }
[01:29:33.286]                       else if (inherits(cond, "warning")) {
[01:29:33.286]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:33.286]                         if (muffled) 
[01:29:33.286]                           invokeRestart("muffleWarning")
[01:29:33.286]                       }
[01:29:33.286]                       else if (inherits(cond, "condition")) {
[01:29:33.286]                         if (!is.null(pattern)) {
[01:29:33.286]                           computeRestarts <- base::computeRestarts
[01:29:33.286]                           grepl <- base::grepl
[01:29:33.286]                           restarts <- computeRestarts(cond)
[01:29:33.286]                           for (restart in restarts) {
[01:29:33.286]                             name <- restart$name
[01:29:33.286]                             if (is.null(name)) 
[01:29:33.286]                               next
[01:29:33.286]                             if (!grepl(pattern, name)) 
[01:29:33.286]                               next
[01:29:33.286]                             invokeRestart(restart)
[01:29:33.286]                             muffled <- TRUE
[01:29:33.286]                             break
[01:29:33.286]                           }
[01:29:33.286]                         }
[01:29:33.286]                       }
[01:29:33.286]                       invisible(muffled)
[01:29:33.286]                     }
[01:29:33.286]                     muffleCondition(cond, pattern = "^muffle")
[01:29:33.286]                   }
[01:29:33.286]                 }
[01:29:33.286]                 else {
[01:29:33.286]                   if (TRUE) {
[01:29:33.286]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.286]                     {
[01:29:33.286]                       inherits <- base::inherits
[01:29:33.286]                       invokeRestart <- base::invokeRestart
[01:29:33.286]                       is.null <- base::is.null
[01:29:33.286]                       muffled <- FALSE
[01:29:33.286]                       if (inherits(cond, "message")) {
[01:29:33.286]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:33.286]                         if (muffled) 
[01:29:33.286]                           invokeRestart("muffleMessage")
[01:29:33.286]                       }
[01:29:33.286]                       else if (inherits(cond, "warning")) {
[01:29:33.286]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:33.286]                         if (muffled) 
[01:29:33.286]                           invokeRestart("muffleWarning")
[01:29:33.286]                       }
[01:29:33.286]                       else if (inherits(cond, "condition")) {
[01:29:33.286]                         if (!is.null(pattern)) {
[01:29:33.286]                           computeRestarts <- base::computeRestarts
[01:29:33.286]                           grepl <- base::grepl
[01:29:33.286]                           restarts <- computeRestarts(cond)
[01:29:33.286]                           for (restart in restarts) {
[01:29:33.286]                             name <- restart$name
[01:29:33.286]                             if (is.null(name)) 
[01:29:33.286]                               next
[01:29:33.286]                             if (!grepl(pattern, name)) 
[01:29:33.286]                               next
[01:29:33.286]                             invokeRestart(restart)
[01:29:33.286]                             muffled <- TRUE
[01:29:33.286]                             break
[01:29:33.286]                           }
[01:29:33.286]                         }
[01:29:33.286]                       }
[01:29:33.286]                       invisible(muffled)
[01:29:33.286]                     }
[01:29:33.286]                     muffleCondition(cond, pattern = "^muffle")
[01:29:33.286]                   }
[01:29:33.286]                 }
[01:29:33.286]             }
[01:29:33.286]         }))
[01:29:33.286]     }, error = function(ex) {
[01:29:33.286]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:33.286]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:33.286]                 ...future.rng), started = ...future.startTime, 
[01:29:33.286]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:33.286]             version = "1.8"), class = "FutureResult")
[01:29:33.286]     }, finally = {
[01:29:33.286]         if (!identical(...future.workdir, getwd())) 
[01:29:33.286]             setwd(...future.workdir)
[01:29:33.286]         {
[01:29:33.286]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:33.286]                 ...future.oldOptions$nwarnings <- NULL
[01:29:33.286]             }
[01:29:33.286]             base::options(...future.oldOptions)
[01:29:33.286]             if (.Platform$OS.type == "windows") {
[01:29:33.286]                 old_names <- names(...future.oldEnvVars)
[01:29:33.286]                 envs <- base::Sys.getenv()
[01:29:33.286]                 names <- names(envs)
[01:29:33.286]                 common <- intersect(names, old_names)
[01:29:33.286]                 added <- setdiff(names, old_names)
[01:29:33.286]                 removed <- setdiff(old_names, names)
[01:29:33.286]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:33.286]                   envs[common]]
[01:29:33.286]                 NAMES <- toupper(changed)
[01:29:33.286]                 args <- list()
[01:29:33.286]                 for (kk in seq_along(NAMES)) {
[01:29:33.286]                   name <- changed[[kk]]
[01:29:33.286]                   NAME <- NAMES[[kk]]
[01:29:33.286]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.286]                     next
[01:29:33.286]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:33.286]                 }
[01:29:33.286]                 NAMES <- toupper(added)
[01:29:33.286]                 for (kk in seq_along(NAMES)) {
[01:29:33.286]                   name <- added[[kk]]
[01:29:33.286]                   NAME <- NAMES[[kk]]
[01:29:33.286]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.286]                     next
[01:29:33.286]                   args[[name]] <- ""
[01:29:33.286]                 }
[01:29:33.286]                 NAMES <- toupper(removed)
[01:29:33.286]                 for (kk in seq_along(NAMES)) {
[01:29:33.286]                   name <- removed[[kk]]
[01:29:33.286]                   NAME <- NAMES[[kk]]
[01:29:33.286]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.286]                     next
[01:29:33.286]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:33.286]                 }
[01:29:33.286]                 if (length(args) > 0) 
[01:29:33.286]                   base::do.call(base::Sys.setenv, args = args)
[01:29:33.286]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:33.286]             }
[01:29:33.286]             else {
[01:29:33.286]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:33.286]             }
[01:29:33.286]             {
[01:29:33.286]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:33.286]                   0L) {
[01:29:33.286]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:33.286]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:33.286]                   base::options(opts)
[01:29:33.286]                 }
[01:29:33.286]                 {
[01:29:33.286]                   {
[01:29:33.286]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:33.286]                     NULL
[01:29:33.286]                   }
[01:29:33.286]                   options(future.plan = NULL)
[01:29:33.286]                   if (is.na(NA_character_)) 
[01:29:33.286]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:33.286]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:33.286]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:33.286]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:33.286]                     envir = parent.frame()) 
[01:29:33.286]                   {
[01:29:33.286]                     if (is.function(workers)) 
[01:29:33.286]                       workers <- workers()
[01:29:33.286]                     workers <- structure(as.integer(workers), 
[01:29:33.286]                       class = class(workers))
[01:29:33.286]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:33.286]                       workers >= 1)
[01:29:33.286]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:33.286]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:33.286]                     }
[01:29:33.286]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:33.286]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:33.286]                       envir = envir)
[01:29:33.286]                     if (!future$lazy) 
[01:29:33.286]                       future <- run(future)
[01:29:33.286]                     invisible(future)
[01:29:33.286]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:33.286]                 }
[01:29:33.286]             }
[01:29:33.286]         }
[01:29:33.286]     })
[01:29:33.286]     if (TRUE) {
[01:29:33.286]         base::sink(type = "output", split = FALSE)
[01:29:33.286]         if (TRUE) {
[01:29:33.286]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:33.286]         }
[01:29:33.286]         else {
[01:29:33.286]             ...future.result["stdout"] <- base::list(NULL)
[01:29:33.286]         }
[01:29:33.286]         base::close(...future.stdout)
[01:29:33.286]         ...future.stdout <- NULL
[01:29:33.286]     }
[01:29:33.286]     ...future.result$conditions <- ...future.conditions
[01:29:33.286]     ...future.result$finished <- base::Sys.time()
[01:29:33.286]     ...future.result
[01:29:33.286] }
[01:29:33.291] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:33.315] receiveMessageFromWorker() for ClusterFuture ...
[01:29:33.316] - Validating connection of MultisessionFuture
[01:29:33.316] - received message: FutureResult
[01:29:33.316] - Received FutureResult
[01:29:33.316] - Erased future from FutureRegistry
[01:29:33.316] result() for ClusterFuture ...
[01:29:33.317] - result already collected: FutureResult
[01:29:33.317] result() for ClusterFuture ... done
[01:29:33.317] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:33.317] result() for ClusterFuture ...
[01:29:33.317] - result already collected: FutureResult
[01:29:33.317] result() for ClusterFuture ... done
[01:29:33.318] result() for ClusterFuture ...
[01:29:33.318] - result already collected: FutureResult
[01:29:33.318] result() for ClusterFuture ... done
[01:29:33.319] Exporting 1 global objects (64 bytes) to cluster node #1 ...
[01:29:33.319] Exporting 'x' (64 bytes) to cluster node #1 ...
[01:29:33.320] Exporting 'x' (64 bytes) to cluster node #1 ... DONE
[01:29:33.320] Exporting 1 global objects (64 bytes) to cluster node #1 ... DONE
[01:29:33.321] MultisessionFuture started
[01:29:33.321] - Launch lazy future ... done
[01:29:33.321] run() for 'MultisessionFuture' ... done
[01:29:33.322] getGlobalsAndPackages() ...
[01:29:33.322] Searching for globals...
[01:29:33.323] - globals found: [3] '{', 'sample', 'x'
[01:29:33.324] Searching for globals ... DONE
[01:29:33.324] Resolving globals: FALSE
[01:29:33.324] The total size of the 1 globals is 64 bytes (64 bytes)
[01:29:33.325] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 64 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (64 bytes of class 'numeric')
[01:29:33.325] - globals: [1] 'x'
[01:29:33.325] 
[01:29:33.325] getGlobalsAndPackages() ... DONE
[01:29:33.326] run() for 'Future' ...
[01:29:33.326] - state: 'created'
[01:29:33.326] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:29:33.342] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:29:33.342] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:29:33.342]   - Field: 'node'
[01:29:33.343]   - Field: 'label'
[01:29:33.343]   - Field: 'local'
[01:29:33.343]   - Field: 'owner'
[01:29:33.343]   - Field: 'envir'
[01:29:33.343]   - Field: 'workers'
[01:29:33.344]   - Field: 'packages'
[01:29:33.344]   - Field: 'gc'
[01:29:33.344]   - Field: 'conditions'
[01:29:33.344]   - Field: 'persistent'
[01:29:33.344]   - Field: 'expr'
[01:29:33.345]   - Field: 'uuid'
[01:29:33.345]   - Field: 'seed'
[01:29:33.345]   - Field: 'version'
[01:29:33.345]   - Field: 'result'
[01:29:33.345]   - Field: 'asynchronous'
[01:29:33.346]   - Field: 'calls'
[01:29:33.346]   - Field: 'globals'
[01:29:33.346]   - Field: 'stdout'
[01:29:33.346]   - Field: 'earlySignal'
[01:29:33.346]   - Field: 'lazy'
[01:29:33.347]   - Field: 'state'
[01:29:33.347] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:29:33.347] - Launch lazy future ...
[01:29:33.347] Packages needed by the future expression (n = 0): <none>
[01:29:33.348] Packages needed by future strategies (n = 0): <none>
[01:29:33.348] {
[01:29:33.348]     {
[01:29:33.348]         {
[01:29:33.348]             ...future.startTime <- base::Sys.time()
[01:29:33.348]             {
[01:29:33.348]                 {
[01:29:33.348]                   {
[01:29:33.348]                     {
[01:29:33.348]                       base::local({
[01:29:33.348]                         has_future <- base::requireNamespace("future", 
[01:29:33.348]                           quietly = TRUE)
[01:29:33.348]                         if (has_future) {
[01:29:33.348]                           ns <- base::getNamespace("future")
[01:29:33.348]                           version <- ns[[".package"]][["version"]]
[01:29:33.348]                           if (is.null(version)) 
[01:29:33.348]                             version <- utils::packageVersion("future")
[01:29:33.348]                         }
[01:29:33.348]                         else {
[01:29:33.348]                           version <- NULL
[01:29:33.348]                         }
[01:29:33.348]                         if (!has_future || version < "1.8.0") {
[01:29:33.348]                           info <- base::c(r_version = base::gsub("R version ", 
[01:29:33.348]                             "", base::R.version$version.string), 
[01:29:33.348]                             platform = base::sprintf("%s (%s-bit)", 
[01:29:33.348]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:29:33.348]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:29:33.348]                               "release", "version")], collapse = " "), 
[01:29:33.348]                             hostname = base::Sys.info()[["nodename"]])
[01:29:33.348]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:29:33.348]                             info)
[01:29:33.348]                           info <- base::paste(info, collapse = "; ")
[01:29:33.348]                           if (!has_future) {
[01:29:33.348]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:29:33.348]                               info)
[01:29:33.348]                           }
[01:29:33.348]                           else {
[01:29:33.348]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:29:33.348]                               info, version)
[01:29:33.348]                           }
[01:29:33.348]                           base::stop(msg)
[01:29:33.348]                         }
[01:29:33.348]                       })
[01:29:33.348]                     }
[01:29:33.348]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:29:33.348]                     base::options(mc.cores = 1L)
[01:29:33.348]                   }
[01:29:33.348]                   options(future.plan = NULL)
[01:29:33.348]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:29:33.348]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:29:33.348]                 }
[01:29:33.348]                 ...future.workdir <- getwd()
[01:29:33.348]             }
[01:29:33.348]             ...future.oldOptions <- base::as.list(base::.Options)
[01:29:33.348]             ...future.oldEnvVars <- base::Sys.getenv()
[01:29:33.348]         }
[01:29:33.348]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[01:29:33.348]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:29:33.348]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[01:29:33.348]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[01:29:33.348]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[01:29:33.348]             future.stdout.windows.reencode = NULL, width = 80L)
[01:29:33.348]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:29:33.348]             base::names(...future.oldOptions))
[01:29:33.348]     }
[01:29:33.348]     if (FALSE) {
[01:29:33.348]     }
[01:29:33.348]     else {
[01:29:33.348]         if (TRUE) {
[01:29:33.348]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:29:33.348]                 open = "w")
[01:29:33.348]         }
[01:29:33.348]         else {
[01:29:33.348]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:29:33.348]                 windows = "NUL", "/dev/null"), open = "w")
[01:29:33.348]         }
[01:29:33.348]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:29:33.348]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:29:33.348]             base::sink(type = "output", split = FALSE)
[01:29:33.348]             base::close(...future.stdout)
[01:29:33.348]         }, add = TRUE)
[01:29:33.348]     }
[01:29:33.348]     ...future.frame <- base::sys.nframe()
[01:29:33.348]     ...future.conditions <- base::list()
[01:29:33.348]     ...future.rng <- base::globalenv()$.Random.seed
[01:29:33.348]     if (FALSE) {
[01:29:33.348]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:29:33.348]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:29:33.348]     }
[01:29:33.348]     ...future.result <- base::tryCatch({
[01:29:33.348]         base::withCallingHandlers({
[01:29:33.348]             ...future.value <- base::withVisible(base::local({
[01:29:33.348]                 ...future.makeSendCondition <- base::local({
[01:29:33.348]                   sendCondition <- NULL
[01:29:33.348]                   function(frame = 1L) {
[01:29:33.348]                     if (is.function(sendCondition)) 
[01:29:33.348]                       return(sendCondition)
[01:29:33.348]                     ns <- getNamespace("parallel")
[01:29:33.348]                     if (exists("sendData", mode = "function", 
[01:29:33.348]                       envir = ns)) {
[01:29:33.348]                       parallel_sendData <- get("sendData", mode = "function", 
[01:29:33.348]                         envir = ns)
[01:29:33.348]                       envir <- sys.frame(frame)
[01:29:33.348]                       master <- NULL
[01:29:33.348]                       while (!identical(envir, .GlobalEnv) && 
[01:29:33.348]                         !identical(envir, emptyenv())) {
[01:29:33.348]                         if (exists("master", mode = "list", envir = envir, 
[01:29:33.348]                           inherits = FALSE)) {
[01:29:33.348]                           master <- get("master", mode = "list", 
[01:29:33.348]                             envir = envir, inherits = FALSE)
[01:29:33.348]                           if (inherits(master, c("SOCKnode", 
[01:29:33.348]                             "SOCK0node"))) {
[01:29:33.348]                             sendCondition <<- function(cond) {
[01:29:33.348]                               data <- list(type = "VALUE", value = cond, 
[01:29:33.348]                                 success = TRUE)
[01:29:33.348]                               parallel_sendData(master, data)
[01:29:33.348]                             }
[01:29:33.348]                             return(sendCondition)
[01:29:33.348]                           }
[01:29:33.348]                         }
[01:29:33.348]                         frame <- frame + 1L
[01:29:33.348]                         envir <- sys.frame(frame)
[01:29:33.348]                       }
[01:29:33.348]                     }
[01:29:33.348]                     sendCondition <<- function(cond) NULL
[01:29:33.348]                   }
[01:29:33.348]                 })
[01:29:33.348]                 withCallingHandlers({
[01:29:33.348]                   {
[01:29:33.348]                     sample(x, size = 1L)
[01:29:33.348]                   }
[01:29:33.348]                 }, immediateCondition = function(cond) {
[01:29:33.348]                   sendCondition <- ...future.makeSendCondition()
[01:29:33.348]                   sendCondition(cond)
[01:29:33.348]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.348]                   {
[01:29:33.348]                     inherits <- base::inherits
[01:29:33.348]                     invokeRestart <- base::invokeRestart
[01:29:33.348]                     is.null <- base::is.null
[01:29:33.348]                     muffled <- FALSE
[01:29:33.348]                     if (inherits(cond, "message")) {
[01:29:33.348]                       muffled <- grepl(pattern, "muffleMessage")
[01:29:33.348]                       if (muffled) 
[01:29:33.348]                         invokeRestart("muffleMessage")
[01:29:33.348]                     }
[01:29:33.348]                     else if (inherits(cond, "warning")) {
[01:29:33.348]                       muffled <- grepl(pattern, "muffleWarning")
[01:29:33.348]                       if (muffled) 
[01:29:33.348]                         invokeRestart("muffleWarning")
[01:29:33.348]                     }
[01:29:33.348]                     else if (inherits(cond, "condition")) {
[01:29:33.348]                       if (!is.null(pattern)) {
[01:29:33.348]                         computeRestarts <- base::computeRestarts
[01:29:33.348]                         grepl <- base::grepl
[01:29:33.348]                         restarts <- computeRestarts(cond)
[01:29:33.348]                         for (restart in restarts) {
[01:29:33.348]                           name <- restart$name
[01:29:33.348]                           if (is.null(name)) 
[01:29:33.348]                             next
[01:29:33.348]                           if (!grepl(pattern, name)) 
[01:29:33.348]                             next
[01:29:33.348]                           invokeRestart(restart)
[01:29:33.348]                           muffled <- TRUE
[01:29:33.348]                           break
[01:29:33.348]                         }
[01:29:33.348]                       }
[01:29:33.348]                     }
[01:29:33.348]                     invisible(muffled)
[01:29:33.348]                   }
[01:29:33.348]                   muffleCondition(cond)
[01:29:33.348]                 })
[01:29:33.348]             }))
[01:29:33.348]             future::FutureResult(value = ...future.value$value, 
[01:29:33.348]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:33.348]                   ...future.rng), globalenv = if (FALSE) 
[01:29:33.348]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:29:33.348]                     ...future.globalenv.names))
[01:29:33.348]                 else NULL, started = ...future.startTime, version = "1.8")
[01:29:33.348]         }, condition = base::local({
[01:29:33.348]             c <- base::c
[01:29:33.348]             inherits <- base::inherits
[01:29:33.348]             invokeRestart <- base::invokeRestart
[01:29:33.348]             length <- base::length
[01:29:33.348]             list <- base::list
[01:29:33.348]             seq.int <- base::seq.int
[01:29:33.348]             signalCondition <- base::signalCondition
[01:29:33.348]             sys.calls <- base::sys.calls
[01:29:33.348]             `[[` <- base::`[[`
[01:29:33.348]             `+` <- base::`+`
[01:29:33.348]             `<<-` <- base::`<<-`
[01:29:33.348]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:29:33.348]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:29:33.348]                   3L)]
[01:29:33.348]             }
[01:29:33.348]             function(cond) {
[01:29:33.348]                 is_error <- inherits(cond, "error")
[01:29:33.348]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:29:33.348]                   NULL)
[01:29:33.348]                 if (is_error) {
[01:29:33.348]                   sessionInformation <- function() {
[01:29:33.348]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:29:33.348]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:29:33.348]                       search = base::search(), system = base::Sys.info())
[01:29:33.348]                   }
[01:29:33.348]                   ...future.conditions[[length(...future.conditions) + 
[01:29:33.348]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:29:33.348]                     cond$call), session = sessionInformation(), 
[01:29:33.348]                     timestamp = base::Sys.time(), signaled = 0L)
[01:29:33.348]                   signalCondition(cond)
[01:29:33.348]                 }
[01:29:33.348]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:29:33.348]                 "immediateCondition"))) {
[01:29:33.348]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:29:33.348]                   ...future.conditions[[length(...future.conditions) + 
[01:29:33.348]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:29:33.348]                   if (TRUE && !signal) {
[01:29:33.348]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.348]                     {
[01:29:33.348]                       inherits <- base::inherits
[01:29:33.348]                       invokeRestart <- base::invokeRestart
[01:29:33.348]                       is.null <- base::is.null
[01:29:33.348]                       muffled <- FALSE
[01:29:33.348]                       if (inherits(cond, "message")) {
[01:29:33.348]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:33.348]                         if (muffled) 
[01:29:33.348]                           invokeRestart("muffleMessage")
[01:29:33.348]                       }
[01:29:33.348]                       else if (inherits(cond, "warning")) {
[01:29:33.348]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:33.348]                         if (muffled) 
[01:29:33.348]                           invokeRestart("muffleWarning")
[01:29:33.348]                       }
[01:29:33.348]                       else if (inherits(cond, "condition")) {
[01:29:33.348]                         if (!is.null(pattern)) {
[01:29:33.348]                           computeRestarts <- base::computeRestarts
[01:29:33.348]                           grepl <- base::grepl
[01:29:33.348]                           restarts <- computeRestarts(cond)
[01:29:33.348]                           for (restart in restarts) {
[01:29:33.348]                             name <- restart$name
[01:29:33.348]                             if (is.null(name)) 
[01:29:33.348]                               next
[01:29:33.348]                             if (!grepl(pattern, name)) 
[01:29:33.348]                               next
[01:29:33.348]                             invokeRestart(restart)
[01:29:33.348]                             muffled <- TRUE
[01:29:33.348]                             break
[01:29:33.348]                           }
[01:29:33.348]                         }
[01:29:33.348]                       }
[01:29:33.348]                       invisible(muffled)
[01:29:33.348]                     }
[01:29:33.348]                     muffleCondition(cond, pattern = "^muffle")
[01:29:33.348]                   }
[01:29:33.348]                 }
[01:29:33.348]                 else {
[01:29:33.348]                   if (TRUE) {
[01:29:33.348]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:29:33.348]                     {
[01:29:33.348]                       inherits <- base::inherits
[01:29:33.348]                       invokeRestart <- base::invokeRestart
[01:29:33.348]                       is.null <- base::is.null
[01:29:33.348]                       muffled <- FALSE
[01:29:33.348]                       if (inherits(cond, "message")) {
[01:29:33.348]                         muffled <- grepl(pattern, "muffleMessage")
[01:29:33.348]                         if (muffled) 
[01:29:33.348]                           invokeRestart("muffleMessage")
[01:29:33.348]                       }
[01:29:33.348]                       else if (inherits(cond, "warning")) {
[01:29:33.348]                         muffled <- grepl(pattern, "muffleWarning")
[01:29:33.348]                         if (muffled) 
[01:29:33.348]                           invokeRestart("muffleWarning")
[01:29:33.348]                       }
[01:29:33.348]                       else if (inherits(cond, "condition")) {
[01:29:33.348]                         if (!is.null(pattern)) {
[01:29:33.348]                           computeRestarts <- base::computeRestarts
[01:29:33.348]                           grepl <- base::grepl
[01:29:33.348]                           restarts <- computeRestarts(cond)
[01:29:33.348]                           for (restart in restarts) {
[01:29:33.348]                             name <- restart$name
[01:29:33.348]                             if (is.null(name)) 
[01:29:33.348]                               next
[01:29:33.348]                             if (!grepl(pattern, name)) 
[01:29:33.348]                               next
[01:29:33.348]                             invokeRestart(restart)
[01:29:33.348]                             muffled <- TRUE
[01:29:33.348]                             break
[01:29:33.348]                           }
[01:29:33.348]                         }
[01:29:33.348]                       }
[01:29:33.348]                       invisible(muffled)
[01:29:33.348]                     }
[01:29:33.348]                     muffleCondition(cond, pattern = "^muffle")
[01:29:33.348]                   }
[01:29:33.348]                 }
[01:29:33.348]             }
[01:29:33.348]         }))
[01:29:33.348]     }, error = function(ex) {
[01:29:33.348]         base::structure(base::list(value = NULL, visible = NULL, 
[01:29:33.348]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:29:33.348]                 ...future.rng), started = ...future.startTime, 
[01:29:33.348]             finished = Sys.time(), session_uuid = NA_character_, 
[01:29:33.348]             version = "1.8"), class = "FutureResult")
[01:29:33.348]     }, finally = {
[01:29:33.348]         if (!identical(...future.workdir, getwd())) 
[01:29:33.348]             setwd(...future.workdir)
[01:29:33.348]         {
[01:29:33.348]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:29:33.348]                 ...future.oldOptions$nwarnings <- NULL
[01:29:33.348]             }
[01:29:33.348]             base::options(...future.oldOptions)
[01:29:33.348]             if (.Platform$OS.type == "windows") {
[01:29:33.348]                 old_names <- names(...future.oldEnvVars)
[01:29:33.348]                 envs <- base::Sys.getenv()
[01:29:33.348]                 names <- names(envs)
[01:29:33.348]                 common <- intersect(names, old_names)
[01:29:33.348]                 added <- setdiff(names, old_names)
[01:29:33.348]                 removed <- setdiff(old_names, names)
[01:29:33.348]                 changed <- common[...future.oldEnvVars[common] != 
[01:29:33.348]                   envs[common]]
[01:29:33.348]                 NAMES <- toupper(changed)
[01:29:33.348]                 args <- list()
[01:29:33.348]                 for (kk in seq_along(NAMES)) {
[01:29:33.348]                   name <- changed[[kk]]
[01:29:33.348]                   NAME <- NAMES[[kk]]
[01:29:33.348]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.348]                     next
[01:29:33.348]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:33.348]                 }
[01:29:33.348]                 NAMES <- toupper(added)
[01:29:33.348]                 for (kk in seq_along(NAMES)) {
[01:29:33.348]                   name <- added[[kk]]
[01:29:33.348]                   NAME <- NAMES[[kk]]
[01:29:33.348]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.348]                     next
[01:29:33.348]                   args[[name]] <- ""
[01:29:33.348]                 }
[01:29:33.348]                 NAMES <- toupper(removed)
[01:29:33.348]                 for (kk in seq_along(NAMES)) {
[01:29:33.348]                   name <- removed[[kk]]
[01:29:33.348]                   NAME <- NAMES[[kk]]
[01:29:33.348]                   if (name != NAME && is.element(NAME, old_names)) 
[01:29:33.348]                     next
[01:29:33.348]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:29:33.348]                 }
[01:29:33.348]                 if (length(args) > 0) 
[01:29:33.348]                   base::do.call(base::Sys.setenv, args = args)
[01:29:33.348]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:29:33.348]             }
[01:29:33.348]             else {
[01:29:33.348]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:29:33.348]             }
[01:29:33.348]             {
[01:29:33.348]                 if (base::length(...future.futureOptionsAdded) > 
[01:29:33.348]                   0L) {
[01:29:33.348]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:29:33.348]                   base::names(opts) <- ...future.futureOptionsAdded
[01:29:33.348]                   base::options(opts)
[01:29:33.348]                 }
[01:29:33.348]                 {
[01:29:33.348]                   {
[01:29:33.348]                     base::options(mc.cores = ...future.mc.cores.old)
[01:29:33.348]                     NULL
[01:29:33.348]                   }
[01:29:33.348]                   options(future.plan = NULL)
[01:29:33.348]                   if (is.na(NA_character_)) 
[01:29:33.348]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:29:33.348]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:29:33.348]                   future::plan(list(function (..., workers = availableCores(), 
[01:29:33.348]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:29:33.348]                     envir = parent.frame()) 
[01:29:33.348]                   {
[01:29:33.348]                     if (is.function(workers)) 
[01:29:33.348]                       workers <- workers()
[01:29:33.348]                     workers <- structure(as.integer(workers), 
[01:29:33.348]                       class = class(workers))
[01:29:33.348]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:29:33.348]                       workers >= 1)
[01:29:33.348]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:29:33.348]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:29:33.348]                     }
[01:29:33.348]                     future <- MultisessionFuture(..., workers = workers, 
[01:29:33.348]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:29:33.348]                       envir = envir)
[01:29:33.348]                     if (!future$lazy) 
[01:29:33.348]                       future <- run(future)
[01:29:33.348]                     invisible(future)
[01:29:33.348]                   }), .cleanup = FALSE, .init = FALSE)
[01:29:33.348]                 }
[01:29:33.348]             }
[01:29:33.348]         }
[01:29:33.348]     })
[01:29:33.348]     if (TRUE) {
[01:29:33.348]         base::sink(type = "output", split = FALSE)
[01:29:33.348]         if (TRUE) {
[01:29:33.348]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:29:33.348]         }
[01:29:33.348]         else {
[01:29:33.348]             ...future.result["stdout"] <- base::list(NULL)
[01:29:33.348]         }
[01:29:33.348]         base::close(...future.stdout)
[01:29:33.348]         ...future.stdout <- NULL
[01:29:33.348]     }
[01:29:33.348]     ...future.result$conditions <- ...future.conditions
[01:29:33.348]     ...future.result$finished <- base::Sys.time()
[01:29:33.348]     ...future.result
[01:29:33.348] }
[01:29:33.353] Poll #1 (0): usedNodes() = 2, workers = 2
[01:29:33.378] receiveMessageFromWorker() for ClusterFuture ...
[01:29:33.379] - Validating connection of MultisessionFuture
[01:29:33.379] - received message: FutureResult
[01:29:33.380] - Received FutureResult
[01:29:33.380] - Erased future from FutureRegistry
[01:29:33.380] result() for ClusterFuture ...
[01:29:33.380] - result already collected: FutureResult
[01:29:33.380] result() for ClusterFuture ... done
[01:29:33.381] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:33.381] result() for ClusterFuture ...
[01:29:33.381] - result already collected: FutureResult
[01:29:33.381] result() for ClusterFuture ... done
[01:29:33.381] result() for ClusterFuture ...
[01:29:33.382] - result already collected: FutureResult
[01:29:33.382] result() for ClusterFuture ... done
[01:29:33.383] Exporting 1 global objects (64 bytes) to cluster node #2 ...
[01:29:33.383] Exporting 'x' (64 bytes) to cluster node #2 ...
[01:29:33.384] Exporting 'x' (64 bytes) to cluster node #2 ... DONE
[01:29:33.384] Exporting 1 global objects (64 bytes) to cluster node #2 ... DONE
[01:29:33.385] MultisessionFuture started
[01:29:33.385] - Launch lazy future ... done
[01:29:33.385] run() for 'MultisessionFuture' ... done
[01:29:33.386] result() for ClusterFuture ...
[01:29:33.386] - result already collected: FutureResult
[01:29:33.386] result() for ClusterFuture ... done
[01:29:33.386] result() for ClusterFuture ...
[01:29:33.386] - result already collected: FutureResult
[01:29:33.386] result() for ClusterFuture ... done
[01:29:33.387] result() for ClusterFuture ...
[01:29:33.387] - result already collected: FutureResult
[01:29:33.387] result() for ClusterFuture ... done
[01:29:33.387] result() for ClusterFuture ...
[01:29:33.387] - result already collected: FutureResult
[01:29:33.388] result() for ClusterFuture ... done
[01:29:33.388] result() for ClusterFuture ...
[01:29:33.388] receiveMessageFromWorker() for ClusterFuture ...
[01:29:33.388] - Validating connection of MultisessionFuture
[01:29:33.388] - received message: FutureResult
[01:29:33.389] - Received FutureResult
[01:29:33.389] - Erased future from FutureRegistry
[01:29:33.389] result() for ClusterFuture ...
[01:29:33.389] - result already collected: FutureResult
[01:29:33.389] result() for ClusterFuture ... done
[01:29:33.390] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:33.390] result() for ClusterFuture ... done
[01:29:33.390] result() for ClusterFuture ...
[01:29:33.390] - result already collected: FutureResult
[01:29:33.390] result() for ClusterFuture ... done
[01:29:33.390] result() for ClusterFuture ...
[01:29:33.391] receiveMessageFromWorker() for ClusterFuture ...
[01:29:33.391] - Validating connection of MultisessionFuture
[01:29:33.406] - received message: FutureResult
[01:29:33.406] - Received FutureResult
[01:29:33.406] - Erased future from FutureRegistry
[01:29:33.407] result() for ClusterFuture ...
[01:29:33.407] - result already collected: FutureResult
[01:29:33.407] result() for ClusterFuture ... done
[01:29:33.407] receiveMessageFromWorker() for ClusterFuture ... done
[01:29:33.407] result() for ClusterFuture ... done
[01:29:33.408] result() for ClusterFuture ...
[01:29:33.408] - result already collected: FutureResult
[01:29:33.408] result() for ClusterFuture ... done
[[1]]
[1] 0

[[2]]
[1] 3

[[3]]
[1] 1

[[4]]
[1] 1

multisession ... done
Testing with 2 cores ... DONE
> 
> message("- Assert that RNG mistakes does not muffle run-time errors")
- Assert that RNG mistakes does not muffle run-time errors
> 
> options(
+   future.debug = FALSE,
+   future.rng.onMisuse = "warning"
+ )
> for (signal in c(TRUE, FALSE)) {
+   message("signal=", signal)
+   f <- future({ sample.int(2L); log("a") }, seed = FALSE)
+   r <- result(f)
+   print(r)
+   res <- tryCatch(value(f, signal = signal), error = identity)
+   print(res)
+   stopifnot(inherits(res, "error"))
+ }
signal=TRUE
FutureResult:
value: 'NULL'
stdout: character
conditions: [n = 1] simpleError
RNG used: TRUE
duration: 0.01809502 secs (started 2023-12-22 01:29:33.434577)
version: 1.8
Warning: UNRELIABLE VALUE: Future ('<none>') unexpectedly generated random numbers without specifying argument 'seed'. There is a risk that those random numbers are not statistically sound and the overall results might be invalid. To fix this, specify 'seed=TRUE'. This ensures that proper, parallel-safe random numbers are produced via the L'Ecuyer-CMRG method. To disable this check, use 'seed=NULL', or set option 'future.rng.onMisuse' to "ignore".
<simpleError in log("a"): non-numeric argument to mathematical function>
signal=FALSE
FutureResult:
value: 'NULL'
stdout: character
conditions: [n = 1] simpleError
RNG used: TRUE
duration: 0.01926017 secs (started 2023-12-22 01:29:33.47323)
version: 1.8
<simpleError in log("a"): non-numeric argument to mathematical function>
> 
> stopifnot(identical(RNGkind(), okind))
> 
> message("*** rng ... DONE")
*** rng ... DONE
> 
> source("incl/end.R")
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 
   5.10    0.29    7.40