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

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

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

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

> source("incl/start.R")
[17:29:39.979] plan(): Setting new future strategy stack:
[17:29:39.981] List of future strategies:
[17:29:39.981] 1. sequential:
[17:29:39.981]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:39.981]    - tweaked: FALSE
[17:29:39.981]    - call: future::plan("sequential")
[17:29:40.008] plan(): nbrOfWorkers() = 1
> 
> message("*** rng ...")
*** rng ...
> 
> okind <- RNGkind()
> 
> ## A valid regular seed
> f <- Future(42, seed = 42L)
[17:29:40.024] getGlobalsAndPackages() ...
[17:29:40.024] 
[17:29:40.025] - globals: [0] <none>
[17:29:40.025] 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: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
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)
[17:29:40.028] getGlobalsAndPackages() ...
[17:29:40.028] 
[17:29:40.028] - globals: [0] <none>
[17:29:40.029] 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: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'Future', 'environment'
> stopifnot(identical(RNGkind(), okind))
> 
> f <- Future(42, seed = TRUE)
[17:29:40.030] getGlobalsAndPackages() ...
[17:29:40.030] 
[17:29:40.031] - globals: [0] <none>
[17:29:40.031] 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, -1494344795, -782050124, -1053044897, -909889013, 339227799, -1111456817)
Resolved: FALSE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'Future', 'environment'
> stopifnot(identical(RNGkind(), okind))
> 
> f <- Future(42, seed = FALSE)
[17:29:40.032] getGlobalsAndPackages() ...
[17:29:40.033] 
[17:29:40.033] - globals: [0] <none>
[17:29:40.033] 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: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'Future', 'environment'
> stopifnot(identical(RNGkind(), okind))
> 
> f <- Future(42, seed = NULL)
[17:29:40.035] getGlobalsAndPackages() ...
[17:29:40.035] 
[17:29:40.036] - globals: [0] <none>
[17:29:40.036] 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: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
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")
[17:29:40.049] plan(): Setting new future strategy stack:
[17:29:40.050] List of future strategies:
[17:29:40.050] 1. sequential:
[17:29:40.050]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.050]    - tweaked: FALSE
[17:29:40.050]    - call: plan("sequential")
[17:29:40.083] plan(): nbrOfWorkers() = 1
> y0 <- fsample(0:3, seed = 42L)
[17:29:40.137] getGlobalsAndPackages() ...
[17:29:40.138] Searching for globals...
[17:29:40.151] - globals found: [3] '{', 'sample', 'x'
[17:29:40.151] Searching for globals ... DONE
[17:29:40.152] Resolving globals: FALSE
[17:29:40.154] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:40.155] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:40.155] - globals: [1] 'x'
[17:29:40.155] 
[17:29:40.156] getGlobalsAndPackages() ... DONE
[17:29:40.157] run() for 'Future' ...
[17:29:40.157] - state: 'created'
[17:29:40.158] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:40.158] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.159] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:40.159]   - Field: 'label'
[17:29:40.160]   - Field: 'local'
[17:29:40.160]   - Field: 'owner'
[17:29:40.160]   - Field: 'envir'
[17:29:40.160]   - Field: 'packages'
[17:29:40.161]   - Field: 'gc'
[17:29:40.161]   - Field: 'conditions'
[17:29:40.161]   - Field: 'expr'
[17:29:40.162]   - Field: 'uuid'
[17:29:40.162]   - Field: 'seed'
[17:29:40.162]   - Field: 'version'
[17:29:40.162]   - Field: 'result'
[17:29:40.163]   - Field: 'asynchronous'
[17:29:40.163]   - Field: 'calls'
[17:29:40.163]   - Field: 'globals'
[17:29:40.163]   - Field: 'stdout'
[17:29:40.164]   - Field: 'earlySignal'
[17:29:40.164]   - Field: 'lazy'
[17:29:40.164]   - Field: 'state'
[17:29:40.164] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:40.165] - Launch lazy future ...
[17:29:40.166] Packages needed by the future expression (n = 0): <none>
[17:29:40.166] Packages needed by future strategies (n = 0): <none>
[17:29:40.168] {
[17:29:40.168]     {
[17:29:40.168]         {
[17:29:40.168]             ...future.startTime <- base::Sys.time()
[17:29:40.168]             {
[17:29:40.168]                 {
[17:29:40.168]                   {
[17:29:40.168]                     {
[17:29:40.168]                       base::local({
[17:29:40.168]                         has_future <- base::requireNamespace("future", 
[17:29:40.168]                           quietly = TRUE)
[17:29:40.168]                         if (has_future) {
[17:29:40.168]                           ns <- base::getNamespace("future")
[17:29:40.168]                           version <- ns[[".package"]][["version"]]
[17:29:40.168]                           if (is.null(version)) 
[17:29:40.168]                             version <- utils::packageVersion("future")
[17:29:40.168]                         }
[17:29:40.168]                         else {
[17:29:40.168]                           version <- NULL
[17:29:40.168]                         }
[17:29:40.168]                         if (!has_future || version < "1.8.0") {
[17:29:40.168]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:40.168]                             "", base::R.version$version.string), 
[17:29:40.168]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:40.168]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:40.168]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:40.168]                               "release", "version")], collapse = " "), 
[17:29:40.168]                             hostname = base::Sys.info()[["nodename"]])
[17:29:40.168]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:40.168]                             info)
[17:29:40.168]                           info <- base::paste(info, collapse = "; ")
[17:29:40.168]                           if (!has_future) {
[17:29:40.168]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:40.168]                               info)
[17:29:40.168]                           }
[17:29:40.168]                           else {
[17:29:40.168]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:40.168]                               info, version)
[17:29:40.168]                           }
[17:29:40.168]                           base::stop(msg)
[17:29:40.168]                         }
[17:29:40.168]                       })
[17:29:40.168]                     }
[17:29:40.168]                     ...future.strategy.old <- future::plan("list")
[17:29:40.168]                     options(future.plan = NULL)
[17:29:40.168]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.168]                     future::plan("default", .cleanup = FALSE, 
[17:29:40.168]                       .init = FALSE)
[17:29:40.168]                   }
[17:29:40.168]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[17:29:40.168]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[17:29:40.168]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[17:29:40.168]                 }
[17:29:40.168]                 ...future.workdir <- getwd()
[17:29:40.168]             }
[17:29:40.168]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:40.168]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:40.168]         }
[17:29:40.168]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:40.168]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:40.168]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:40.168]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:40.168]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:40.168]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:40.168]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:40.168]             base::names(...future.oldOptions))
[17:29:40.168]     }
[17:29:40.168]     if (FALSE) {
[17:29:40.168]     }
[17:29:40.168]     else {
[17:29:40.168]         if (TRUE) {
[17:29:40.168]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:40.168]                 open = "w")
[17:29:40.168]         }
[17:29:40.168]         else {
[17:29:40.168]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:40.168]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:40.168]         }
[17:29:40.168]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:40.168]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:40.168]             base::sink(type = "output", split = FALSE)
[17:29:40.168]             base::close(...future.stdout)
[17:29:40.168]         }, add = TRUE)
[17:29:40.168]     }
[17:29:40.168]     ...future.frame <- base::sys.nframe()
[17:29:40.168]     ...future.conditions <- base::list()
[17:29:40.168]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:40.168]     if (FALSE) {
[17:29:40.168]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:40.168]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:40.168]     }
[17:29:40.168]     ...future.result <- base::tryCatch({
[17:29:40.168]         base::withCallingHandlers({
[17:29:40.168]             ...future.value <- base::withVisible(base::local({
[17:29:40.168]                 sample(x, size = 1L)
[17:29:40.168]             }))
[17:29:40.168]             future::FutureResult(value = ...future.value$value, 
[17:29:40.168]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.168]                   ...future.rng), globalenv = if (FALSE) 
[17:29:40.168]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:40.168]                     ...future.globalenv.names))
[17:29:40.168]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:40.168]         }, condition = base::local({
[17:29:40.168]             c <- base::c
[17:29:40.168]             inherits <- base::inherits
[17:29:40.168]             invokeRestart <- base::invokeRestart
[17:29:40.168]             length <- base::length
[17:29:40.168]             list <- base::list
[17:29:40.168]             seq.int <- base::seq.int
[17:29:40.168]             signalCondition <- base::signalCondition
[17:29:40.168]             sys.calls <- base::sys.calls
[17:29:40.168]             `[[` <- base::`[[`
[17:29:40.168]             `+` <- base::`+`
[17:29:40.168]             `<<-` <- base::`<<-`
[17:29:40.168]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:40.168]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:40.168]                   3L)]
[17:29:40.168]             }
[17:29:40.168]             function(cond) {
[17:29:40.168]                 is_error <- inherits(cond, "error")
[17:29:40.168]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:40.168]                   NULL)
[17:29:40.168]                 if (is_error) {
[17:29:40.168]                   sessionInformation <- function() {
[17:29:40.168]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:40.168]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:40.168]                       search = base::search(), system = base::Sys.info())
[17:29:40.168]                   }
[17:29:40.168]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.168]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:40.168]                     cond$call), session = sessionInformation(), 
[17:29:40.168]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:40.168]                   signalCondition(cond)
[17:29:40.168]                 }
[17:29:40.168]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:40.168]                 "immediateCondition"))) {
[17:29:40.168]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:40.168]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.168]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:40.168]                   if (TRUE && !signal) {
[17:29:40.168]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.168]                     {
[17:29:40.168]                       inherits <- base::inherits
[17:29:40.168]                       invokeRestart <- base::invokeRestart
[17:29:40.168]                       is.null <- base::is.null
[17:29:40.168]                       muffled <- FALSE
[17:29:40.168]                       if (inherits(cond, "message")) {
[17:29:40.168]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.168]                         if (muffled) 
[17:29:40.168]                           invokeRestart("muffleMessage")
[17:29:40.168]                       }
[17:29:40.168]                       else if (inherits(cond, "warning")) {
[17:29:40.168]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.168]                         if (muffled) 
[17:29:40.168]                           invokeRestart("muffleWarning")
[17:29:40.168]                       }
[17:29:40.168]                       else if (inherits(cond, "condition")) {
[17:29:40.168]                         if (!is.null(pattern)) {
[17:29:40.168]                           computeRestarts <- base::computeRestarts
[17:29:40.168]                           grepl <- base::grepl
[17:29:40.168]                           restarts <- computeRestarts(cond)
[17:29:40.168]                           for (restart in restarts) {
[17:29:40.168]                             name <- restart$name
[17:29:40.168]                             if (is.null(name)) 
[17:29:40.168]                               next
[17:29:40.168]                             if (!grepl(pattern, name)) 
[17:29:40.168]                               next
[17:29:40.168]                             invokeRestart(restart)
[17:29:40.168]                             muffled <- TRUE
[17:29:40.168]                             break
[17:29:40.168]                           }
[17:29:40.168]                         }
[17:29:40.168]                       }
[17:29:40.168]                       invisible(muffled)
[17:29:40.168]                     }
[17:29:40.168]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.168]                   }
[17:29:40.168]                 }
[17:29:40.168]                 else {
[17:29:40.168]                   if (TRUE) {
[17:29:40.168]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.168]                     {
[17:29:40.168]                       inherits <- base::inherits
[17:29:40.168]                       invokeRestart <- base::invokeRestart
[17:29:40.168]                       is.null <- base::is.null
[17:29:40.168]                       muffled <- FALSE
[17:29:40.168]                       if (inherits(cond, "message")) {
[17:29:40.168]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.168]                         if (muffled) 
[17:29:40.168]                           invokeRestart("muffleMessage")
[17:29:40.168]                       }
[17:29:40.168]                       else if (inherits(cond, "warning")) {
[17:29:40.168]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.168]                         if (muffled) 
[17:29:40.168]                           invokeRestart("muffleWarning")
[17:29:40.168]                       }
[17:29:40.168]                       else if (inherits(cond, "condition")) {
[17:29:40.168]                         if (!is.null(pattern)) {
[17:29:40.168]                           computeRestarts <- base::computeRestarts
[17:29:40.168]                           grepl <- base::grepl
[17:29:40.168]                           restarts <- computeRestarts(cond)
[17:29:40.168]                           for (restart in restarts) {
[17:29:40.168]                             name <- restart$name
[17:29:40.168]                             if (is.null(name)) 
[17:29:40.168]                               next
[17:29:40.168]                             if (!grepl(pattern, name)) 
[17:29:40.168]                               next
[17:29:40.168]                             invokeRestart(restart)
[17:29:40.168]                             muffled <- TRUE
[17:29:40.168]                             break
[17:29:40.168]                           }
[17:29:40.168]                         }
[17:29:40.168]                       }
[17:29:40.168]                       invisible(muffled)
[17:29:40.168]                     }
[17:29:40.168]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.168]                   }
[17:29:40.168]                 }
[17:29:40.168]             }
[17:29:40.168]         }))
[17:29:40.168]     }, error = function(ex) {
[17:29:40.168]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:40.168]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.168]                 ...future.rng), started = ...future.startTime, 
[17:29:40.168]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:40.168]             version = "1.8"), class = "FutureResult")
[17:29:40.168]     }, finally = {
[17:29:40.168]         if (!identical(...future.workdir, getwd())) 
[17:29:40.168]             setwd(...future.workdir)
[17:29:40.168]         {
[17:29:40.168]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:40.168]                 ...future.oldOptions$nwarnings <- NULL
[17:29:40.168]             }
[17:29:40.168]             base::options(...future.oldOptions)
[17:29:40.168]             if (.Platform$OS.type == "windows") {
[17:29:40.168]                 old_names <- names(...future.oldEnvVars)
[17:29:40.168]                 envs <- base::Sys.getenv()
[17:29:40.168]                 names <- names(envs)
[17:29:40.168]                 common <- intersect(names, old_names)
[17:29:40.168]                 added <- setdiff(names, old_names)
[17:29:40.168]                 removed <- setdiff(old_names, names)
[17:29:40.168]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:40.168]                   envs[common]]
[17:29:40.168]                 NAMES <- toupper(changed)
[17:29:40.168]                 args <- list()
[17:29:40.168]                 for (kk in seq_along(NAMES)) {
[17:29:40.168]                   name <- changed[[kk]]
[17:29:40.168]                   NAME <- NAMES[[kk]]
[17:29:40.168]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.168]                     next
[17:29:40.168]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.168]                 }
[17:29:40.168]                 NAMES <- toupper(added)
[17:29:40.168]                 for (kk in seq_along(NAMES)) {
[17:29:40.168]                   name <- added[[kk]]
[17:29:40.168]                   NAME <- NAMES[[kk]]
[17:29:40.168]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.168]                     next
[17:29:40.168]                   args[[name]] <- ""
[17:29:40.168]                 }
[17:29:40.168]                 NAMES <- toupper(removed)
[17:29:40.168]                 for (kk in seq_along(NAMES)) {
[17:29:40.168]                   name <- removed[[kk]]
[17:29:40.168]                   NAME <- NAMES[[kk]]
[17:29:40.168]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.168]                     next
[17:29:40.168]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.168]                 }
[17:29:40.168]                 if (length(args) > 0) 
[17:29:40.168]                   base::do.call(base::Sys.setenv, args = args)
[17:29:40.168]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:40.168]             }
[17:29:40.168]             else {
[17:29:40.168]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:40.168]             }
[17:29:40.168]             {
[17:29:40.168]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:40.168]                   0L) {
[17:29:40.168]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:40.168]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:40.168]                   base::options(opts)
[17:29:40.168]                 }
[17:29:40.168]                 {
[17:29:40.168]                   {
[17:29:40.168]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:40.168]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:40.168]                     -1344458670L), envir = base::globalenv(), 
[17:29:40.168]                       inherits = FALSE)
[17:29:40.168]                     NULL
[17:29:40.168]                   }
[17:29:40.168]                   options(future.plan = NULL)
[17:29:40.168]                   if (is.na(NA_character_)) 
[17:29:40.168]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.168]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:40.168]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:40.168]                     .init = FALSE)
[17:29:40.168]                 }
[17:29:40.168]             }
[17:29:40.168]         }
[17:29:40.168]     })
[17:29:40.168]     if (TRUE) {
[17:29:40.168]         base::sink(type = "output", split = FALSE)
[17:29:40.168]         if (TRUE) {
[17:29:40.168]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:40.168]         }
[17:29:40.168]         else {
[17:29:40.168]             ...future.result["stdout"] <- base::list(NULL)
[17:29:40.168]         }
[17:29:40.168]         base::close(...future.stdout)
[17:29:40.168]         ...future.stdout <- NULL
[17:29:40.168]     }
[17:29:40.168]     ...future.result$conditions <- ...future.conditions
[17:29:40.168]     ...future.result$finished <- base::Sys.time()
[17:29:40.168]     ...future.result
[17:29:40.168] }
[17:29:40.174] assign_globals() ...
[17:29:40.174] List of 1
[17:29:40.174]  $ x: int [1:4] 0 1 2 3
[17:29:40.174]  - attr(*, "where")=List of 1
[17:29:40.174]   ..$ x:<environment: R_EmptyEnv> 
[17:29:40.174]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:40.174]  - attr(*, "resolved")= logi FALSE
[17:29:40.174]  - attr(*, "total_size")= int 133
[17:29:40.174]  - attr(*, "already-done")= logi TRUE
[17:29:40.187] - copied 'x' to environment
[17:29:40.188] assign_globals() ... done
[17:29:40.189] plan(): Setting new future strategy stack:
[17:29:40.189] List of future strategies:
[17:29:40.189] 1. sequential:
[17:29:40.189]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.189]    - tweaked: FALSE
[17:29:40.189]    - call: NULL
[17:29:40.190] plan(): nbrOfWorkers() = 1
[17:29:40.193] plan(): Setting new future strategy stack:
[17:29:40.194] List of future strategies:
[17:29:40.194] 1. sequential:
[17:29:40.194]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.194]    - tweaked: FALSE
[17:29:40.194]    - call: plan("sequential")
[17:29:40.195] plan(): nbrOfWorkers() = 1
[17:29:40.195] SequentialFuture started (and completed)
[17:29:40.196] - Launch lazy future ... done
[17:29:40.197] run() for 'SequentialFuture' ... done
[17:29:40.197] getGlobalsAndPackages() ...
[17:29:40.197] Searching for globals...
[17:29:40.200] - globals found: [3] '{', 'sample', 'x'
[17:29:40.200] Searching for globals ... DONE
[17:29:40.200] Resolving globals: FALSE
[17:29:40.201] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:40.202] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:40.202] - globals: [1] 'x'
[17:29:40.203] 
[17:29:40.203] getGlobalsAndPackages() ... DONE
[17:29:40.203] run() for 'Future' ...
[17:29:40.204] - state: 'created'
[17:29:40.204] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:40.205] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.205] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:40.205]   - Field: 'label'
[17:29:40.206]   - Field: 'local'
[17:29:40.206]   - Field: 'owner'
[17:29:40.206]   - Field: 'envir'
[17:29:40.207]   - Field: 'packages'
[17:29:40.207]   - Field: 'gc'
[17:29:40.207]   - Field: 'conditions'
[17:29:40.207]   - Field: 'expr'
[17:29:40.208]   - Field: 'uuid'
[17:29:40.208]   - Field: 'seed'
[17:29:40.208]   - Field: 'version'
[17:29:40.209]   - Field: 'result'
[17:29:40.209]   - Field: 'asynchronous'
[17:29:40.209]   - Field: 'calls'
[17:29:40.210]   - Field: 'globals'
[17:29:40.210]   - Field: 'stdout'
[17:29:40.210]   - Field: 'earlySignal'
[17:29:40.210]   - Field: 'lazy'
[17:29:40.211]   - Field: 'state'
[17:29:40.211] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:40.211] - Launch lazy future ...
[17:29:40.212] Packages needed by the future expression (n = 0): <none>
[17:29:40.212] Packages needed by future strategies (n = 0): <none>
[17:29:40.213] {
[17:29:40.213]     {
[17:29:40.213]         {
[17:29:40.213]             ...future.startTime <- base::Sys.time()
[17:29:40.213]             {
[17:29:40.213]                 {
[17:29:40.213]                   {
[17:29:40.213]                     {
[17:29:40.213]                       base::local({
[17:29:40.213]                         has_future <- base::requireNamespace("future", 
[17:29:40.213]                           quietly = TRUE)
[17:29:40.213]                         if (has_future) {
[17:29:40.213]                           ns <- base::getNamespace("future")
[17:29:40.213]                           version <- ns[[".package"]][["version"]]
[17:29:40.213]                           if (is.null(version)) 
[17:29:40.213]                             version <- utils::packageVersion("future")
[17:29:40.213]                         }
[17:29:40.213]                         else {
[17:29:40.213]                           version <- NULL
[17:29:40.213]                         }
[17:29:40.213]                         if (!has_future || version < "1.8.0") {
[17:29:40.213]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:40.213]                             "", base::R.version$version.string), 
[17:29:40.213]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:40.213]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:40.213]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:40.213]                               "release", "version")], collapse = " "), 
[17:29:40.213]                             hostname = base::Sys.info()[["nodename"]])
[17:29:40.213]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:40.213]                             info)
[17:29:40.213]                           info <- base::paste(info, collapse = "; ")
[17:29:40.213]                           if (!has_future) {
[17:29:40.213]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:40.213]                               info)
[17:29:40.213]                           }
[17:29:40.213]                           else {
[17:29:40.213]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:40.213]                               info, version)
[17:29:40.213]                           }
[17:29:40.213]                           base::stop(msg)
[17:29:40.213]                         }
[17:29:40.213]                       })
[17:29:40.213]                     }
[17:29:40.213]                     ...future.strategy.old <- future::plan("list")
[17:29:40.213]                     options(future.plan = NULL)
[17:29:40.213]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.213]                     future::plan("default", .cleanup = FALSE, 
[17:29:40.213]                       .init = FALSE)
[17:29:40.213]                   }
[17:29:40.213]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[17:29:40.213]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[17:29:40.213]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[17:29:40.213]                 }
[17:29:40.213]                 ...future.workdir <- getwd()
[17:29:40.213]             }
[17:29:40.213]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:40.213]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:40.213]         }
[17:29:40.213]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:40.213]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:40.213]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:40.213]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:40.213]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:40.213]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:40.213]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:40.213]             base::names(...future.oldOptions))
[17:29:40.213]     }
[17:29:40.213]     if (FALSE) {
[17:29:40.213]     }
[17:29:40.213]     else {
[17:29:40.213]         if (TRUE) {
[17:29:40.213]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:40.213]                 open = "w")
[17:29:40.213]         }
[17:29:40.213]         else {
[17:29:40.213]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:40.213]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:40.213]         }
[17:29:40.213]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:40.213]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:40.213]             base::sink(type = "output", split = FALSE)
[17:29:40.213]             base::close(...future.stdout)
[17:29:40.213]         }, add = TRUE)
[17:29:40.213]     }
[17:29:40.213]     ...future.frame <- base::sys.nframe()
[17:29:40.213]     ...future.conditions <- base::list()
[17:29:40.213]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:40.213]     if (FALSE) {
[17:29:40.213]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:40.213]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:40.213]     }
[17:29:40.213]     ...future.result <- base::tryCatch({
[17:29:40.213]         base::withCallingHandlers({
[17:29:40.213]             ...future.value <- base::withVisible(base::local({
[17:29:40.213]                 sample(x, size = 1L)
[17:29:40.213]             }))
[17:29:40.213]             future::FutureResult(value = ...future.value$value, 
[17:29:40.213]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.213]                   ...future.rng), globalenv = if (FALSE) 
[17:29:40.213]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:40.213]                     ...future.globalenv.names))
[17:29:40.213]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:40.213]         }, condition = base::local({
[17:29:40.213]             c <- base::c
[17:29:40.213]             inherits <- base::inherits
[17:29:40.213]             invokeRestart <- base::invokeRestart
[17:29:40.213]             length <- base::length
[17:29:40.213]             list <- base::list
[17:29:40.213]             seq.int <- base::seq.int
[17:29:40.213]             signalCondition <- base::signalCondition
[17:29:40.213]             sys.calls <- base::sys.calls
[17:29:40.213]             `[[` <- base::`[[`
[17:29:40.213]             `+` <- base::`+`
[17:29:40.213]             `<<-` <- base::`<<-`
[17:29:40.213]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:40.213]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:40.213]                   3L)]
[17:29:40.213]             }
[17:29:40.213]             function(cond) {
[17:29:40.213]                 is_error <- inherits(cond, "error")
[17:29:40.213]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:40.213]                   NULL)
[17:29:40.213]                 if (is_error) {
[17:29:40.213]                   sessionInformation <- function() {
[17:29:40.213]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:40.213]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:40.213]                       search = base::search(), system = base::Sys.info())
[17:29:40.213]                   }
[17:29:40.213]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.213]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:40.213]                     cond$call), session = sessionInformation(), 
[17:29:40.213]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:40.213]                   signalCondition(cond)
[17:29:40.213]                 }
[17:29:40.213]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:40.213]                 "immediateCondition"))) {
[17:29:40.213]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:40.213]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.213]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:40.213]                   if (TRUE && !signal) {
[17:29:40.213]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.213]                     {
[17:29:40.213]                       inherits <- base::inherits
[17:29:40.213]                       invokeRestart <- base::invokeRestart
[17:29:40.213]                       is.null <- base::is.null
[17:29:40.213]                       muffled <- FALSE
[17:29:40.213]                       if (inherits(cond, "message")) {
[17:29:40.213]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.213]                         if (muffled) 
[17:29:40.213]                           invokeRestart("muffleMessage")
[17:29:40.213]                       }
[17:29:40.213]                       else if (inherits(cond, "warning")) {
[17:29:40.213]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.213]                         if (muffled) 
[17:29:40.213]                           invokeRestart("muffleWarning")
[17:29:40.213]                       }
[17:29:40.213]                       else if (inherits(cond, "condition")) {
[17:29:40.213]                         if (!is.null(pattern)) {
[17:29:40.213]                           computeRestarts <- base::computeRestarts
[17:29:40.213]                           grepl <- base::grepl
[17:29:40.213]                           restarts <- computeRestarts(cond)
[17:29:40.213]                           for (restart in restarts) {
[17:29:40.213]                             name <- restart$name
[17:29:40.213]                             if (is.null(name)) 
[17:29:40.213]                               next
[17:29:40.213]                             if (!grepl(pattern, name)) 
[17:29:40.213]                               next
[17:29:40.213]                             invokeRestart(restart)
[17:29:40.213]                             muffled <- TRUE
[17:29:40.213]                             break
[17:29:40.213]                           }
[17:29:40.213]                         }
[17:29:40.213]                       }
[17:29:40.213]                       invisible(muffled)
[17:29:40.213]                     }
[17:29:40.213]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.213]                   }
[17:29:40.213]                 }
[17:29:40.213]                 else {
[17:29:40.213]                   if (TRUE) {
[17:29:40.213]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.213]                     {
[17:29:40.213]                       inherits <- base::inherits
[17:29:40.213]                       invokeRestart <- base::invokeRestart
[17:29:40.213]                       is.null <- base::is.null
[17:29:40.213]                       muffled <- FALSE
[17:29:40.213]                       if (inherits(cond, "message")) {
[17:29:40.213]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.213]                         if (muffled) 
[17:29:40.213]                           invokeRestart("muffleMessage")
[17:29:40.213]                       }
[17:29:40.213]                       else if (inherits(cond, "warning")) {
[17:29:40.213]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.213]                         if (muffled) 
[17:29:40.213]                           invokeRestart("muffleWarning")
[17:29:40.213]                       }
[17:29:40.213]                       else if (inherits(cond, "condition")) {
[17:29:40.213]                         if (!is.null(pattern)) {
[17:29:40.213]                           computeRestarts <- base::computeRestarts
[17:29:40.213]                           grepl <- base::grepl
[17:29:40.213]                           restarts <- computeRestarts(cond)
[17:29:40.213]                           for (restart in restarts) {
[17:29:40.213]                             name <- restart$name
[17:29:40.213]                             if (is.null(name)) 
[17:29:40.213]                               next
[17:29:40.213]                             if (!grepl(pattern, name)) 
[17:29:40.213]                               next
[17:29:40.213]                             invokeRestart(restart)
[17:29:40.213]                             muffled <- TRUE
[17:29:40.213]                             break
[17:29:40.213]                           }
[17:29:40.213]                         }
[17:29:40.213]                       }
[17:29:40.213]                       invisible(muffled)
[17:29:40.213]                     }
[17:29:40.213]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.213]                   }
[17:29:40.213]                 }
[17:29:40.213]             }
[17:29:40.213]         }))
[17:29:40.213]     }, error = function(ex) {
[17:29:40.213]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:40.213]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.213]                 ...future.rng), started = ...future.startTime, 
[17:29:40.213]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:40.213]             version = "1.8"), class = "FutureResult")
[17:29:40.213]     }, finally = {
[17:29:40.213]         if (!identical(...future.workdir, getwd())) 
[17:29:40.213]             setwd(...future.workdir)
[17:29:40.213]         {
[17:29:40.213]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:40.213]                 ...future.oldOptions$nwarnings <- NULL
[17:29:40.213]             }
[17:29:40.213]             base::options(...future.oldOptions)
[17:29:40.213]             if (.Platform$OS.type == "windows") {
[17:29:40.213]                 old_names <- names(...future.oldEnvVars)
[17:29:40.213]                 envs <- base::Sys.getenv()
[17:29:40.213]                 names <- names(envs)
[17:29:40.213]                 common <- intersect(names, old_names)
[17:29:40.213]                 added <- setdiff(names, old_names)
[17:29:40.213]                 removed <- setdiff(old_names, names)
[17:29:40.213]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:40.213]                   envs[common]]
[17:29:40.213]                 NAMES <- toupper(changed)
[17:29:40.213]                 args <- list()
[17:29:40.213]                 for (kk in seq_along(NAMES)) {
[17:29:40.213]                   name <- changed[[kk]]
[17:29:40.213]                   NAME <- NAMES[[kk]]
[17:29:40.213]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.213]                     next
[17:29:40.213]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.213]                 }
[17:29:40.213]                 NAMES <- toupper(added)
[17:29:40.213]                 for (kk in seq_along(NAMES)) {
[17:29:40.213]                   name <- added[[kk]]
[17:29:40.213]                   NAME <- NAMES[[kk]]
[17:29:40.213]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.213]                     next
[17:29:40.213]                   args[[name]] <- ""
[17:29:40.213]                 }
[17:29:40.213]                 NAMES <- toupper(removed)
[17:29:40.213]                 for (kk in seq_along(NAMES)) {
[17:29:40.213]                   name <- removed[[kk]]
[17:29:40.213]                   NAME <- NAMES[[kk]]
[17:29:40.213]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.213]                     next
[17:29:40.213]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.213]                 }
[17:29:40.213]                 if (length(args) > 0) 
[17:29:40.213]                   base::do.call(base::Sys.setenv, args = args)
[17:29:40.213]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:40.213]             }
[17:29:40.213]             else {
[17:29:40.213]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:40.213]             }
[17:29:40.213]             {
[17:29:40.213]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:40.213]                   0L) {
[17:29:40.213]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:40.213]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:40.213]                   base::options(opts)
[17:29:40.213]                 }
[17:29:40.213]                 {
[17:29:40.213]                   {
[17:29:40.213]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:40.213]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:40.213]                     -1344458670L), envir = base::globalenv(), 
[17:29:40.213]                       inherits = FALSE)
[17:29:40.213]                     NULL
[17:29:40.213]                   }
[17:29:40.213]                   options(future.plan = NULL)
[17:29:40.213]                   if (is.na(NA_character_)) 
[17:29:40.213]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.213]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:40.213]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:40.213]                     .init = FALSE)
[17:29:40.213]                 }
[17:29:40.213]             }
[17:29:40.213]         }
[17:29:40.213]     })
[17:29:40.213]     if (TRUE) {
[17:29:40.213]         base::sink(type = "output", split = FALSE)
[17:29:40.213]         if (TRUE) {
[17:29:40.213]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:40.213]         }
[17:29:40.213]         else {
[17:29:40.213]             ...future.result["stdout"] <- base::list(NULL)
[17:29:40.213]         }
[17:29:40.213]         base::close(...future.stdout)
[17:29:40.213]         ...future.stdout <- NULL
[17:29:40.213]     }
[17:29:40.213]     ...future.result$conditions <- ...future.conditions
[17:29:40.213]     ...future.result$finished <- base::Sys.time()
[17:29:40.213]     ...future.result
[17:29:40.213] }
[17:29:40.220] assign_globals() ...
[17:29:40.220] List of 1
[17:29:40.220]  $ x: int [1:4] 0 1 2 3
[17:29:40.220]  - attr(*, "where")=List of 1
[17:29:40.220]   ..$ x:<environment: R_EmptyEnv> 
[17:29:40.220]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:40.220]  - attr(*, "resolved")= logi FALSE
[17:29:40.220]  - attr(*, "total_size")= int 133
[17:29:40.220]  - attr(*, "already-done")= logi TRUE
[17:29:40.226] - copied 'x' to environment
[17:29:40.226] assign_globals() ... done
[17:29:40.227] plan(): Setting new future strategy stack:
[17:29:40.227] List of future strategies:
[17:29:40.227] 1. sequential:
[17:29:40.227]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.227]    - tweaked: FALSE
[17:29:40.227]    - call: NULL
[17:29:40.228] plan(): nbrOfWorkers() = 1
[17:29:40.231] plan(): Setting new future strategy stack:
[17:29:40.231] List of future strategies:
[17:29:40.231] 1. sequential:
[17:29:40.231]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.231]    - tweaked: FALSE
[17:29:40.231]    - call: plan("sequential")
[17:29:40.232] plan(): nbrOfWorkers() = 1
[17:29:40.232] SequentialFuture started (and completed)
[17:29:40.233] - Launch lazy future ... done
[17:29:40.233] run() for 'SequentialFuture' ... done
[17:29:40.233] getGlobalsAndPackages() ...
[17:29:40.234] Searching for globals...
[17:29:40.236] - globals found: [3] '{', 'sample', 'x'
[17:29:40.236] Searching for globals ... DONE
[17:29:40.237] Resolving globals: FALSE
[17:29:40.238] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:40.238] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:40.239] - globals: [1] 'x'
[17:29:40.239] 
[17:29:40.239] getGlobalsAndPackages() ... DONE
[17:29:40.240] run() for 'Future' ...
[17:29:40.240] - state: 'created'
[17:29:40.245] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:40.245] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.246] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:40.246]   - Field: 'label'
[17:29:40.246]   - Field: 'local'
[17:29:40.246]   - Field: 'owner'
[17:29:40.247]   - Field: 'envir'
[17:29:40.247]   - Field: 'packages'
[17:29:40.247]   - Field: 'gc'
[17:29:40.247]   - Field: 'conditions'
[17:29:40.247]   - Field: 'expr'
[17:29:40.248]   - Field: 'uuid'
[17:29:40.248]   - Field: 'seed'
[17:29:40.248]   - Field: 'version'
[17:29:40.248]   - Field: 'result'
[17:29:40.249]   - Field: 'asynchronous'
[17:29:40.249]   - Field: 'calls'
[17:29:40.249]   - Field: 'globals'
[17:29:40.249]   - Field: 'stdout'
[17:29:40.249]   - Field: 'earlySignal'
[17:29:40.250]   - Field: 'lazy'
[17:29:40.250]   - Field: 'state'
[17:29:40.250] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:40.250] - Launch lazy future ...
[17:29:40.251] Packages needed by the future expression (n = 0): <none>
[17:29:40.251] Packages needed by future strategies (n = 0): <none>
[17:29:40.252] {
[17:29:40.252]     {
[17:29:40.252]         {
[17:29:40.252]             ...future.startTime <- base::Sys.time()
[17:29:40.252]             {
[17:29:40.252]                 {
[17:29:40.252]                   {
[17:29:40.252]                     {
[17:29:40.252]                       base::local({
[17:29:40.252]                         has_future <- base::requireNamespace("future", 
[17:29:40.252]                           quietly = TRUE)
[17:29:40.252]                         if (has_future) {
[17:29:40.252]                           ns <- base::getNamespace("future")
[17:29:40.252]                           version <- ns[[".package"]][["version"]]
[17:29:40.252]                           if (is.null(version)) 
[17:29:40.252]                             version <- utils::packageVersion("future")
[17:29:40.252]                         }
[17:29:40.252]                         else {
[17:29:40.252]                           version <- NULL
[17:29:40.252]                         }
[17:29:40.252]                         if (!has_future || version < "1.8.0") {
[17:29:40.252]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:40.252]                             "", base::R.version$version.string), 
[17:29:40.252]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:40.252]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:40.252]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:40.252]                               "release", "version")], collapse = " "), 
[17:29:40.252]                             hostname = base::Sys.info()[["nodename"]])
[17:29:40.252]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:40.252]                             info)
[17:29:40.252]                           info <- base::paste(info, collapse = "; ")
[17:29:40.252]                           if (!has_future) {
[17:29:40.252]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:40.252]                               info)
[17:29:40.252]                           }
[17:29:40.252]                           else {
[17:29:40.252]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:40.252]                               info, version)
[17:29:40.252]                           }
[17:29:40.252]                           base::stop(msg)
[17:29:40.252]                         }
[17:29:40.252]                       })
[17:29:40.252]                     }
[17:29:40.252]                     ...future.strategy.old <- future::plan("list")
[17:29:40.252]                     options(future.plan = NULL)
[17:29:40.252]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.252]                     future::plan("default", .cleanup = FALSE, 
[17:29:40.252]                       .init = FALSE)
[17:29:40.252]                   }
[17:29:40.252]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[17:29:40.252]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[17:29:40.252]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[17:29:40.252]                 }
[17:29:40.252]                 ...future.workdir <- getwd()
[17:29:40.252]             }
[17:29:40.252]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:40.252]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:40.252]         }
[17:29:40.252]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:40.252]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:40.252]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:40.252]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:40.252]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:40.252]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:40.252]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:40.252]             base::names(...future.oldOptions))
[17:29:40.252]     }
[17:29:40.252]     if (FALSE) {
[17:29:40.252]     }
[17:29:40.252]     else {
[17:29:40.252]         if (TRUE) {
[17:29:40.252]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:40.252]                 open = "w")
[17:29:40.252]         }
[17:29:40.252]         else {
[17:29:40.252]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:40.252]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:40.252]         }
[17:29:40.252]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:40.252]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:40.252]             base::sink(type = "output", split = FALSE)
[17:29:40.252]             base::close(...future.stdout)
[17:29:40.252]         }, add = TRUE)
[17:29:40.252]     }
[17:29:40.252]     ...future.frame <- base::sys.nframe()
[17:29:40.252]     ...future.conditions <- base::list()
[17:29:40.252]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:40.252]     if (FALSE) {
[17:29:40.252]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:40.252]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:40.252]     }
[17:29:40.252]     ...future.result <- base::tryCatch({
[17:29:40.252]         base::withCallingHandlers({
[17:29:40.252]             ...future.value <- base::withVisible(base::local({
[17:29:40.252]                 sample(x, size = 1L)
[17:29:40.252]             }))
[17:29:40.252]             future::FutureResult(value = ...future.value$value, 
[17:29:40.252]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.252]                   ...future.rng), globalenv = if (FALSE) 
[17:29:40.252]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:40.252]                     ...future.globalenv.names))
[17:29:40.252]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:40.252]         }, condition = base::local({
[17:29:40.252]             c <- base::c
[17:29:40.252]             inherits <- base::inherits
[17:29:40.252]             invokeRestart <- base::invokeRestart
[17:29:40.252]             length <- base::length
[17:29:40.252]             list <- base::list
[17:29:40.252]             seq.int <- base::seq.int
[17:29:40.252]             signalCondition <- base::signalCondition
[17:29:40.252]             sys.calls <- base::sys.calls
[17:29:40.252]             `[[` <- base::`[[`
[17:29:40.252]             `+` <- base::`+`
[17:29:40.252]             `<<-` <- base::`<<-`
[17:29:40.252]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:40.252]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:40.252]                   3L)]
[17:29:40.252]             }
[17:29:40.252]             function(cond) {
[17:29:40.252]                 is_error <- inherits(cond, "error")
[17:29:40.252]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:40.252]                   NULL)
[17:29:40.252]                 if (is_error) {
[17:29:40.252]                   sessionInformation <- function() {
[17:29:40.252]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:40.252]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:40.252]                       search = base::search(), system = base::Sys.info())
[17:29:40.252]                   }
[17:29:40.252]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.252]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:40.252]                     cond$call), session = sessionInformation(), 
[17:29:40.252]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:40.252]                   signalCondition(cond)
[17:29:40.252]                 }
[17:29:40.252]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:40.252]                 "immediateCondition"))) {
[17:29:40.252]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:40.252]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.252]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:40.252]                   if (TRUE && !signal) {
[17:29:40.252]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.252]                     {
[17:29:40.252]                       inherits <- base::inherits
[17:29:40.252]                       invokeRestart <- base::invokeRestart
[17:29:40.252]                       is.null <- base::is.null
[17:29:40.252]                       muffled <- FALSE
[17:29:40.252]                       if (inherits(cond, "message")) {
[17:29:40.252]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.252]                         if (muffled) 
[17:29:40.252]                           invokeRestart("muffleMessage")
[17:29:40.252]                       }
[17:29:40.252]                       else if (inherits(cond, "warning")) {
[17:29:40.252]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.252]                         if (muffled) 
[17:29:40.252]                           invokeRestart("muffleWarning")
[17:29:40.252]                       }
[17:29:40.252]                       else if (inherits(cond, "condition")) {
[17:29:40.252]                         if (!is.null(pattern)) {
[17:29:40.252]                           computeRestarts <- base::computeRestarts
[17:29:40.252]                           grepl <- base::grepl
[17:29:40.252]                           restarts <- computeRestarts(cond)
[17:29:40.252]                           for (restart in restarts) {
[17:29:40.252]                             name <- restart$name
[17:29:40.252]                             if (is.null(name)) 
[17:29:40.252]                               next
[17:29:40.252]                             if (!grepl(pattern, name)) 
[17:29:40.252]                               next
[17:29:40.252]                             invokeRestart(restart)
[17:29:40.252]                             muffled <- TRUE
[17:29:40.252]                             break
[17:29:40.252]                           }
[17:29:40.252]                         }
[17:29:40.252]                       }
[17:29:40.252]                       invisible(muffled)
[17:29:40.252]                     }
[17:29:40.252]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.252]                   }
[17:29:40.252]                 }
[17:29:40.252]                 else {
[17:29:40.252]                   if (TRUE) {
[17:29:40.252]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.252]                     {
[17:29:40.252]                       inherits <- base::inherits
[17:29:40.252]                       invokeRestart <- base::invokeRestart
[17:29:40.252]                       is.null <- base::is.null
[17:29:40.252]                       muffled <- FALSE
[17:29:40.252]                       if (inherits(cond, "message")) {
[17:29:40.252]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.252]                         if (muffled) 
[17:29:40.252]                           invokeRestart("muffleMessage")
[17:29:40.252]                       }
[17:29:40.252]                       else if (inherits(cond, "warning")) {
[17:29:40.252]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.252]                         if (muffled) 
[17:29:40.252]                           invokeRestart("muffleWarning")
[17:29:40.252]                       }
[17:29:40.252]                       else if (inherits(cond, "condition")) {
[17:29:40.252]                         if (!is.null(pattern)) {
[17:29:40.252]                           computeRestarts <- base::computeRestarts
[17:29:40.252]                           grepl <- base::grepl
[17:29:40.252]                           restarts <- computeRestarts(cond)
[17:29:40.252]                           for (restart in restarts) {
[17:29:40.252]                             name <- restart$name
[17:29:40.252]                             if (is.null(name)) 
[17:29:40.252]                               next
[17:29:40.252]                             if (!grepl(pattern, name)) 
[17:29:40.252]                               next
[17:29:40.252]                             invokeRestart(restart)
[17:29:40.252]                             muffled <- TRUE
[17:29:40.252]                             break
[17:29:40.252]                           }
[17:29:40.252]                         }
[17:29:40.252]                       }
[17:29:40.252]                       invisible(muffled)
[17:29:40.252]                     }
[17:29:40.252]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.252]                   }
[17:29:40.252]                 }
[17:29:40.252]             }
[17:29:40.252]         }))
[17:29:40.252]     }, error = function(ex) {
[17:29:40.252]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:40.252]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.252]                 ...future.rng), started = ...future.startTime, 
[17:29:40.252]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:40.252]             version = "1.8"), class = "FutureResult")
[17:29:40.252]     }, finally = {
[17:29:40.252]         if (!identical(...future.workdir, getwd())) 
[17:29:40.252]             setwd(...future.workdir)
[17:29:40.252]         {
[17:29:40.252]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:40.252]                 ...future.oldOptions$nwarnings <- NULL
[17:29:40.252]             }
[17:29:40.252]             base::options(...future.oldOptions)
[17:29:40.252]             if (.Platform$OS.type == "windows") {
[17:29:40.252]                 old_names <- names(...future.oldEnvVars)
[17:29:40.252]                 envs <- base::Sys.getenv()
[17:29:40.252]                 names <- names(envs)
[17:29:40.252]                 common <- intersect(names, old_names)
[17:29:40.252]                 added <- setdiff(names, old_names)
[17:29:40.252]                 removed <- setdiff(old_names, names)
[17:29:40.252]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:40.252]                   envs[common]]
[17:29:40.252]                 NAMES <- toupper(changed)
[17:29:40.252]                 args <- list()
[17:29:40.252]                 for (kk in seq_along(NAMES)) {
[17:29:40.252]                   name <- changed[[kk]]
[17:29:40.252]                   NAME <- NAMES[[kk]]
[17:29:40.252]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.252]                     next
[17:29:40.252]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.252]                 }
[17:29:40.252]                 NAMES <- toupper(added)
[17:29:40.252]                 for (kk in seq_along(NAMES)) {
[17:29:40.252]                   name <- added[[kk]]
[17:29:40.252]                   NAME <- NAMES[[kk]]
[17:29:40.252]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.252]                     next
[17:29:40.252]                   args[[name]] <- ""
[17:29:40.252]                 }
[17:29:40.252]                 NAMES <- toupper(removed)
[17:29:40.252]                 for (kk in seq_along(NAMES)) {
[17:29:40.252]                   name <- removed[[kk]]
[17:29:40.252]                   NAME <- NAMES[[kk]]
[17:29:40.252]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.252]                     next
[17:29:40.252]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.252]                 }
[17:29:40.252]                 if (length(args) > 0) 
[17:29:40.252]                   base::do.call(base::Sys.setenv, args = args)
[17:29:40.252]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:40.252]             }
[17:29:40.252]             else {
[17:29:40.252]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:40.252]             }
[17:29:40.252]             {
[17:29:40.252]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:40.252]                   0L) {
[17:29:40.252]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:40.252]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:40.252]                   base::options(opts)
[17:29:40.252]                 }
[17:29:40.252]                 {
[17:29:40.252]                   {
[17:29:40.252]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:40.252]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:40.252]                     -1344458670L), envir = base::globalenv(), 
[17:29:40.252]                       inherits = FALSE)
[17:29:40.252]                     NULL
[17:29:40.252]                   }
[17:29:40.252]                   options(future.plan = NULL)
[17:29:40.252]                   if (is.na(NA_character_)) 
[17:29:40.252]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.252]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:40.252]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:40.252]                     .init = FALSE)
[17:29:40.252]                 }
[17:29:40.252]             }
[17:29:40.252]         }
[17:29:40.252]     })
[17:29:40.252]     if (TRUE) {
[17:29:40.252]         base::sink(type = "output", split = FALSE)
[17:29:40.252]         if (TRUE) {
[17:29:40.252]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:40.252]         }
[17:29:40.252]         else {
[17:29:40.252]             ...future.result["stdout"] <- base::list(NULL)
[17:29:40.252]         }
[17:29:40.252]         base::close(...future.stdout)
[17:29:40.252]         ...future.stdout <- NULL
[17:29:40.252]     }
[17:29:40.252]     ...future.result$conditions <- ...future.conditions
[17:29:40.252]     ...future.result$finished <- base::Sys.time()
[17:29:40.252]     ...future.result
[17:29:40.252] }
[17:29:40.258] assign_globals() ...
[17:29:40.258] List of 1
[17:29:40.258]  $ x: int [1:4] 0 1 2 3
[17:29:40.258]  - attr(*, "where")=List of 1
[17:29:40.258]   ..$ x:<environment: R_EmptyEnv> 
[17:29:40.258]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:40.258]  - attr(*, "resolved")= logi FALSE
[17:29:40.258]  - attr(*, "total_size")= int 133
[17:29:40.258]  - attr(*, "already-done")= logi TRUE
[17:29:40.264] - copied 'x' to environment
[17:29:40.264] assign_globals() ... done
[17:29:40.265] plan(): Setting new future strategy stack:
[17:29:40.266] List of future strategies:
[17:29:40.266] 1. sequential:
[17:29:40.266]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.266]    - tweaked: FALSE
[17:29:40.266]    - call: NULL
[17:29:40.267] plan(): nbrOfWorkers() = 1
[17:29:40.269] plan(): Setting new future strategy stack:
[17:29:40.270] List of future strategies:
[17:29:40.270] 1. sequential:
[17:29:40.270]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.270]    - tweaked: FALSE
[17:29:40.270]    - call: plan("sequential")
[17:29:40.271] plan(): nbrOfWorkers() = 1
[17:29:40.271] SequentialFuture started (and completed)
[17:29:40.272] - Launch lazy future ... done
[17:29:40.272] run() for 'SequentialFuture' ... done
[17:29:40.272] getGlobalsAndPackages() ...
[17:29:40.273] Searching for globals...
[17:29:40.275] - globals found: [3] '{', 'sample', 'x'
[17:29:40.276] Searching for globals ... DONE
[17:29:40.276] Resolving globals: FALSE
[17:29:40.277] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:40.278] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:40.278] - globals: [1] 'x'
[17:29:40.279] 
[17:29:40.279] getGlobalsAndPackages() ... DONE
[17:29:40.280] run() for 'Future' ...
[17:29:40.280] - state: 'created'
[17:29:40.281] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:40.281] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.282] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:40.282]   - Field: 'label'
[17:29:40.282]   - Field: 'local'
[17:29:40.283]   - Field: 'owner'
[17:29:40.283]   - Field: 'envir'
[17:29:40.283]   - Field: 'packages'
[17:29:40.284]   - Field: 'gc'
[17:29:40.284]   - Field: 'conditions'
[17:29:40.284]   - Field: 'expr'
[17:29:40.285]   - Field: 'uuid'
[17:29:40.285]   - Field: 'seed'
[17:29:40.285]   - Field: 'version'
[17:29:40.286]   - Field: 'result'
[17:29:40.286]   - Field: 'asynchronous'
[17:29:40.286]   - Field: 'calls'
[17:29:40.287]   - Field: 'globals'
[17:29:40.287]   - Field: 'stdout'
[17:29:40.287]   - Field: 'earlySignal'
[17:29:40.288]   - Field: 'lazy'
[17:29:40.288]   - Field: 'state'
[17:29:40.288] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:40.289] - Launch lazy future ...
[17:29:40.289] Packages needed by the future expression (n = 0): <none>
[17:29:40.290] Packages needed by future strategies (n = 0): <none>
[17:29:40.291] {
[17:29:40.291]     {
[17:29:40.291]         {
[17:29:40.291]             ...future.startTime <- base::Sys.time()
[17:29:40.291]             {
[17:29:40.291]                 {
[17:29:40.291]                   {
[17:29:40.291]                     {
[17:29:40.291]                       base::local({
[17:29:40.291]                         has_future <- base::requireNamespace("future", 
[17:29:40.291]                           quietly = TRUE)
[17:29:40.291]                         if (has_future) {
[17:29:40.291]                           ns <- base::getNamespace("future")
[17:29:40.291]                           version <- ns[[".package"]][["version"]]
[17:29:40.291]                           if (is.null(version)) 
[17:29:40.291]                             version <- utils::packageVersion("future")
[17:29:40.291]                         }
[17:29:40.291]                         else {
[17:29:40.291]                           version <- NULL
[17:29:40.291]                         }
[17:29:40.291]                         if (!has_future || version < "1.8.0") {
[17:29:40.291]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:40.291]                             "", base::R.version$version.string), 
[17:29:40.291]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:40.291]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:40.291]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:40.291]                               "release", "version")], collapse = " "), 
[17:29:40.291]                             hostname = base::Sys.info()[["nodename"]])
[17:29:40.291]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:40.291]                             info)
[17:29:40.291]                           info <- base::paste(info, collapse = "; ")
[17:29:40.291]                           if (!has_future) {
[17:29:40.291]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:40.291]                               info)
[17:29:40.291]                           }
[17:29:40.291]                           else {
[17:29:40.291]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:40.291]                               info, version)
[17:29:40.291]                           }
[17:29:40.291]                           base::stop(msg)
[17:29:40.291]                         }
[17:29:40.291]                       })
[17:29:40.291]                     }
[17:29:40.291]                     ...future.strategy.old <- future::plan("list")
[17:29:40.291]                     options(future.plan = NULL)
[17:29:40.291]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.291]                     future::plan("default", .cleanup = FALSE, 
[17:29:40.291]                       .init = FALSE)
[17:29:40.291]                   }
[17:29:40.291]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[17:29:40.291]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[17:29:40.291]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[17:29:40.291]                 }
[17:29:40.291]                 ...future.workdir <- getwd()
[17:29:40.291]             }
[17:29:40.291]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:40.291]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:40.291]         }
[17:29:40.291]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:40.291]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:40.291]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:40.291]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:40.291]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:40.291]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:40.291]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:40.291]             base::names(...future.oldOptions))
[17:29:40.291]     }
[17:29:40.291]     if (FALSE) {
[17:29:40.291]     }
[17:29:40.291]     else {
[17:29:40.291]         if (TRUE) {
[17:29:40.291]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:40.291]                 open = "w")
[17:29:40.291]         }
[17:29:40.291]         else {
[17:29:40.291]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:40.291]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:40.291]         }
[17:29:40.291]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:40.291]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:40.291]             base::sink(type = "output", split = FALSE)
[17:29:40.291]             base::close(...future.stdout)
[17:29:40.291]         }, add = TRUE)
[17:29:40.291]     }
[17:29:40.291]     ...future.frame <- base::sys.nframe()
[17:29:40.291]     ...future.conditions <- base::list()
[17:29:40.291]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:40.291]     if (FALSE) {
[17:29:40.291]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:40.291]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:40.291]     }
[17:29:40.291]     ...future.result <- base::tryCatch({
[17:29:40.291]         base::withCallingHandlers({
[17:29:40.291]             ...future.value <- base::withVisible(base::local({
[17:29:40.291]                 sample(x, size = 1L)
[17:29:40.291]             }))
[17:29:40.291]             future::FutureResult(value = ...future.value$value, 
[17:29:40.291]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.291]                   ...future.rng), globalenv = if (FALSE) 
[17:29:40.291]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:40.291]                     ...future.globalenv.names))
[17:29:40.291]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:40.291]         }, condition = base::local({
[17:29:40.291]             c <- base::c
[17:29:40.291]             inherits <- base::inherits
[17:29:40.291]             invokeRestart <- base::invokeRestart
[17:29:40.291]             length <- base::length
[17:29:40.291]             list <- base::list
[17:29:40.291]             seq.int <- base::seq.int
[17:29:40.291]             signalCondition <- base::signalCondition
[17:29:40.291]             sys.calls <- base::sys.calls
[17:29:40.291]             `[[` <- base::`[[`
[17:29:40.291]             `+` <- base::`+`
[17:29:40.291]             `<<-` <- base::`<<-`
[17:29:40.291]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:40.291]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:40.291]                   3L)]
[17:29:40.291]             }
[17:29:40.291]             function(cond) {
[17:29:40.291]                 is_error <- inherits(cond, "error")
[17:29:40.291]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:40.291]                   NULL)
[17:29:40.291]                 if (is_error) {
[17:29:40.291]                   sessionInformation <- function() {
[17:29:40.291]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:40.291]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:40.291]                       search = base::search(), system = base::Sys.info())
[17:29:40.291]                   }
[17:29:40.291]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.291]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:40.291]                     cond$call), session = sessionInformation(), 
[17:29:40.291]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:40.291]                   signalCondition(cond)
[17:29:40.291]                 }
[17:29:40.291]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:40.291]                 "immediateCondition"))) {
[17:29:40.291]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:40.291]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.291]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:40.291]                   if (TRUE && !signal) {
[17:29:40.291]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.291]                     {
[17:29:40.291]                       inherits <- base::inherits
[17:29:40.291]                       invokeRestart <- base::invokeRestart
[17:29:40.291]                       is.null <- base::is.null
[17:29:40.291]                       muffled <- FALSE
[17:29:40.291]                       if (inherits(cond, "message")) {
[17:29:40.291]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.291]                         if (muffled) 
[17:29:40.291]                           invokeRestart("muffleMessage")
[17:29:40.291]                       }
[17:29:40.291]                       else if (inherits(cond, "warning")) {
[17:29:40.291]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.291]                         if (muffled) 
[17:29:40.291]                           invokeRestart("muffleWarning")
[17:29:40.291]                       }
[17:29:40.291]                       else if (inherits(cond, "condition")) {
[17:29:40.291]                         if (!is.null(pattern)) {
[17:29:40.291]                           computeRestarts <- base::computeRestarts
[17:29:40.291]                           grepl <- base::grepl
[17:29:40.291]                           restarts <- computeRestarts(cond)
[17:29:40.291]                           for (restart in restarts) {
[17:29:40.291]                             name <- restart$name
[17:29:40.291]                             if (is.null(name)) 
[17:29:40.291]                               next
[17:29:40.291]                             if (!grepl(pattern, name)) 
[17:29:40.291]                               next
[17:29:40.291]                             invokeRestart(restart)
[17:29:40.291]                             muffled <- TRUE
[17:29:40.291]                             break
[17:29:40.291]                           }
[17:29:40.291]                         }
[17:29:40.291]                       }
[17:29:40.291]                       invisible(muffled)
[17:29:40.291]                     }
[17:29:40.291]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.291]                   }
[17:29:40.291]                 }
[17:29:40.291]                 else {
[17:29:40.291]                   if (TRUE) {
[17:29:40.291]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.291]                     {
[17:29:40.291]                       inherits <- base::inherits
[17:29:40.291]                       invokeRestart <- base::invokeRestart
[17:29:40.291]                       is.null <- base::is.null
[17:29:40.291]                       muffled <- FALSE
[17:29:40.291]                       if (inherits(cond, "message")) {
[17:29:40.291]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.291]                         if (muffled) 
[17:29:40.291]                           invokeRestart("muffleMessage")
[17:29:40.291]                       }
[17:29:40.291]                       else if (inherits(cond, "warning")) {
[17:29:40.291]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.291]                         if (muffled) 
[17:29:40.291]                           invokeRestart("muffleWarning")
[17:29:40.291]                       }
[17:29:40.291]                       else if (inherits(cond, "condition")) {
[17:29:40.291]                         if (!is.null(pattern)) {
[17:29:40.291]                           computeRestarts <- base::computeRestarts
[17:29:40.291]                           grepl <- base::grepl
[17:29:40.291]                           restarts <- computeRestarts(cond)
[17:29:40.291]                           for (restart in restarts) {
[17:29:40.291]                             name <- restart$name
[17:29:40.291]                             if (is.null(name)) 
[17:29:40.291]                               next
[17:29:40.291]                             if (!grepl(pattern, name)) 
[17:29:40.291]                               next
[17:29:40.291]                             invokeRestart(restart)
[17:29:40.291]                             muffled <- TRUE
[17:29:40.291]                             break
[17:29:40.291]                           }
[17:29:40.291]                         }
[17:29:40.291]                       }
[17:29:40.291]                       invisible(muffled)
[17:29:40.291]                     }
[17:29:40.291]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.291]                   }
[17:29:40.291]                 }
[17:29:40.291]             }
[17:29:40.291]         }))
[17:29:40.291]     }, error = function(ex) {
[17:29:40.291]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:40.291]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.291]                 ...future.rng), started = ...future.startTime, 
[17:29:40.291]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:40.291]             version = "1.8"), class = "FutureResult")
[17:29:40.291]     }, finally = {
[17:29:40.291]         if (!identical(...future.workdir, getwd())) 
[17:29:40.291]             setwd(...future.workdir)
[17:29:40.291]         {
[17:29:40.291]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:40.291]                 ...future.oldOptions$nwarnings <- NULL
[17:29:40.291]             }
[17:29:40.291]             base::options(...future.oldOptions)
[17:29:40.291]             if (.Platform$OS.type == "windows") {
[17:29:40.291]                 old_names <- names(...future.oldEnvVars)
[17:29:40.291]                 envs <- base::Sys.getenv()
[17:29:40.291]                 names <- names(envs)
[17:29:40.291]                 common <- intersect(names, old_names)
[17:29:40.291]                 added <- setdiff(names, old_names)
[17:29:40.291]                 removed <- setdiff(old_names, names)
[17:29:40.291]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:40.291]                   envs[common]]
[17:29:40.291]                 NAMES <- toupper(changed)
[17:29:40.291]                 args <- list()
[17:29:40.291]                 for (kk in seq_along(NAMES)) {
[17:29:40.291]                   name <- changed[[kk]]
[17:29:40.291]                   NAME <- NAMES[[kk]]
[17:29:40.291]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.291]                     next
[17:29:40.291]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.291]                 }
[17:29:40.291]                 NAMES <- toupper(added)
[17:29:40.291]                 for (kk in seq_along(NAMES)) {
[17:29:40.291]                   name <- added[[kk]]
[17:29:40.291]                   NAME <- NAMES[[kk]]
[17:29:40.291]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.291]                     next
[17:29:40.291]                   args[[name]] <- ""
[17:29:40.291]                 }
[17:29:40.291]                 NAMES <- toupper(removed)
[17:29:40.291]                 for (kk in seq_along(NAMES)) {
[17:29:40.291]                   name <- removed[[kk]]
[17:29:40.291]                   NAME <- NAMES[[kk]]
[17:29:40.291]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.291]                     next
[17:29:40.291]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.291]                 }
[17:29:40.291]                 if (length(args) > 0) 
[17:29:40.291]                   base::do.call(base::Sys.setenv, args = args)
[17:29:40.291]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:40.291]             }
[17:29:40.291]             else {
[17:29:40.291]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:40.291]             }
[17:29:40.291]             {
[17:29:40.291]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:40.291]                   0L) {
[17:29:40.291]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:40.291]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:40.291]                   base::options(opts)
[17:29:40.291]                 }
[17:29:40.291]                 {
[17:29:40.291]                   {
[17:29:40.291]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:40.291]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:40.291]                     -1344458670L), envir = base::globalenv(), 
[17:29:40.291]                       inherits = FALSE)
[17:29:40.291]                     NULL
[17:29:40.291]                   }
[17:29:40.291]                   options(future.plan = NULL)
[17:29:40.291]                   if (is.na(NA_character_)) 
[17:29:40.291]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.291]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:40.291]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:40.291]                     .init = FALSE)
[17:29:40.291]                 }
[17:29:40.291]             }
[17:29:40.291]         }
[17:29:40.291]     })
[17:29:40.291]     if (TRUE) {
[17:29:40.291]         base::sink(type = "output", split = FALSE)
[17:29:40.291]         if (TRUE) {
[17:29:40.291]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:40.291]         }
[17:29:40.291]         else {
[17:29:40.291]             ...future.result["stdout"] <- base::list(NULL)
[17:29:40.291]         }
[17:29:40.291]         base::close(...future.stdout)
[17:29:40.291]         ...future.stdout <- NULL
[17:29:40.291]     }
[17:29:40.291]     ...future.result$conditions <- ...future.conditions
[17:29:40.291]     ...future.result$finished <- base::Sys.time()
[17:29:40.291]     ...future.result
[17:29:40.291] }
[17:29:40.298] assign_globals() ...
[17:29:40.298] List of 1
[17:29:40.298]  $ x: int [1:4] 0 1 2 3
[17:29:40.298]  - attr(*, "where")=List of 1
[17:29:40.298]   ..$ x:<environment: R_EmptyEnv> 
[17:29:40.298]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:40.298]  - attr(*, "resolved")= logi FALSE
[17:29:40.298]  - attr(*, "total_size")= int 133
[17:29:40.298]  - attr(*, "already-done")= logi TRUE
[17:29:40.305] - copied 'x' to environment
[17:29:40.305] assign_globals() ... done
[17:29:40.306] plan(): Setting new future strategy stack:
[17:29:40.306] List of future strategies:
[17:29:40.306] 1. sequential:
[17:29:40.306]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.306]    - tweaked: FALSE
[17:29:40.306]    - call: NULL
[17:29:40.307] plan(): nbrOfWorkers() = 1
[17:29:40.310] plan(): Setting new future strategy stack:
[17:29:40.315] List of future strategies:
[17:29:40.315] 1. sequential:
[17:29:40.315]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.315]    - tweaked: FALSE
[17:29:40.315]    - call: plan("sequential")
[17:29:40.316] plan(): nbrOfWorkers() = 1
[17:29:40.316] SequentialFuture started (and completed)
[17:29:40.317] - Launch lazy future ... done
[17:29:40.317] run() for 'SequentialFuture' ... done
[17:29:40.318] resolve() on list ...
[17:29:40.318]  recursive: 0
[17:29:40.319]  length: 4
[17:29:40.319] 
[17:29:40.320] resolved() for 'SequentialFuture' ...
[17:29:40.320] - state: 'finished'
[17:29:40.321] - run: TRUE
[17:29:40.321] - result: 'FutureResult'
[17:29:40.321] resolved() for 'SequentialFuture' ... done
[17:29:40.322] Future #1
[17:29:40.323] signalConditionsASAP(SequentialFuture, pos=1) ...
[17:29:40.323] - nx: 4
[17:29:40.323] - relay: TRUE
[17:29:40.323] - stdout: TRUE
[17:29:40.324] - signal: TRUE
[17:29:40.324] - resignal: FALSE
[17:29:40.324] - force: TRUE
[17:29:40.325] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:40.325] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:40.325]  - until=1
[17:29:40.325]  - relaying element #1
[17:29:40.326] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:40.326] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:40.327] signalConditionsASAP(SequentialFuture, pos=1) ... done
[17:29:40.327]  length: 3 (resolved future 1)
[17:29:40.328] resolved() for 'SequentialFuture' ...
[17:29:40.328] - state: 'finished'
[17:29:40.328] - run: TRUE
[17:29:40.329] - result: 'FutureResult'
[17:29:40.329] resolved() for 'SequentialFuture' ... done
[17:29:40.329] Future #2
[17:29:40.330] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:29:40.330] - nx: 4
[17:29:40.330] - relay: TRUE
[17:29:40.331] - stdout: TRUE
[17:29:40.331] - signal: TRUE
[17:29:40.331] - resignal: FALSE
[17:29:40.331] - force: TRUE
[17:29:40.332] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:40.332] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:40.332]  - until=2
[17:29:40.333]  - relaying element #2
[17:29:40.333] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:40.334] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:40.334] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:29:40.334]  length: 2 (resolved future 2)
[17:29:40.335] resolved() for 'SequentialFuture' ...
[17:29:40.335] - state: 'finished'
[17:29:40.335] - run: TRUE
[17:29:40.336] - result: 'FutureResult'
[17:29:40.336] resolved() for 'SequentialFuture' ... done
[17:29:40.336] Future #3
[17:29:40.337] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:29:40.337] - nx: 4
[17:29:40.337] - relay: TRUE
[17:29:40.338] - stdout: TRUE
[17:29:40.338] - signal: TRUE
[17:29:40.338] - resignal: FALSE
[17:29:40.338] - force: TRUE
[17:29:40.339] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:40.339] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:40.339]  - until=3
[17:29:40.340]  - relaying element #3
[17:29:40.340] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:40.340] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:40.341] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:29:40.341]  length: 1 (resolved future 3)
[17:29:40.341] resolved() for 'SequentialFuture' ...
[17:29:40.342] - state: 'finished'
[17:29:40.342] - run: TRUE
[17:29:40.342] - result: 'FutureResult'
[17:29:40.343] resolved() for 'SequentialFuture' ... done
[17:29:40.343] Future #4
[17:29:40.344] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:29:40.344] - nx: 4
[17:29:40.344] - relay: TRUE
[17:29:40.344] - stdout: TRUE
[17:29:40.345] - signal: TRUE
[17:29:40.345] - resignal: FALSE
[17:29:40.345] - force: TRUE
[17:29:40.346] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:40.346] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:40.346]  - until=4
[17:29:40.346]  - relaying element #4
[17:29:40.347] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.347] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.348] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:29:40.348]  length: 0 (resolved future 4)
[17:29:40.348] Relaying remaining futures
[17:29:40.349] signalConditionsASAP(NULL, pos=0) ...
[17:29:40.349] - nx: 4
[17:29:40.349] - relay: TRUE
[17:29:40.349] - stdout: TRUE
[17:29:40.350] - signal: TRUE
[17:29:40.350] - resignal: FALSE
[17:29:40.350] - force: TRUE
[17:29:40.351] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.351] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:29:40.352] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.352] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.352] signalConditionsASAP(NULL, pos=0) ... done
[17:29:40.353] 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 ...
[17:29:40.432] plan(): Setting new future strategy stack:
[17:29:40.433] List of future strategies:
[17:29:40.433] 1. sequential:
[17:29:40.433]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.433]    - tweaked: FALSE
[17:29:40.433]    - call: plan(strategy)
[17:29:40.434] plan(): nbrOfWorkers() = 1
[17:29:40.434] getGlobalsAndPackages() ...
[17:29:40.435] Searching for globals...
[17:29:40.437] - globals found: [3] '{', 'sample', 'x'
[17:29:40.437] Searching for globals ... DONE
[17:29:40.438] Resolving globals: FALSE
[17:29:40.439] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:40.439] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:40.440] - globals: [1] 'x'
[17:29:40.440] 
[17:29:40.440] getGlobalsAndPackages() ... DONE
[17:29:40.441] run() for 'Future' ...
[17:29:40.441] - state: 'created'
[17:29:40.442] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:40.442] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.443] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:40.443]   - Field: 'label'
[17:29:40.443]   - Field: 'local'
[17:29:40.444]   - Field: 'owner'
[17:29:40.444]   - Field: 'envir'
[17:29:40.444]   - Field: 'packages'
[17:29:40.445]   - Field: 'gc'
[17:29:40.445]   - Field: 'conditions'
[17:29:40.445]   - Field: 'expr'
[17:29:40.446]   - Field: 'uuid'
[17:29:40.446]   - Field: 'seed'
[17:29:40.446]   - Field: 'version'
[17:29:40.447]   - Field: 'result'
[17:29:40.447]   - Field: 'asynchronous'
[17:29:40.447]   - Field: 'calls'
[17:29:40.448]   - Field: 'globals'
[17:29:40.448]   - Field: 'stdout'
[17:29:40.448]   - Field: 'earlySignal'
[17:29:40.449]   - Field: 'lazy'
[17:29:40.449]   - Field: 'state'
[17:29:40.449] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:40.450] - Launch lazy future ...
[17:29:40.450] Packages needed by the future expression (n = 0): <none>
[17:29:40.450] Packages needed by future strategies (n = 0): <none>
[17:29:40.451] {
[17:29:40.451]     {
[17:29:40.451]         {
[17:29:40.451]             ...future.startTime <- base::Sys.time()
[17:29:40.451]             {
[17:29:40.451]                 {
[17:29:40.451]                   {
[17:29:40.451]                     {
[17:29:40.451]                       base::local({
[17:29:40.451]                         has_future <- base::requireNamespace("future", 
[17:29:40.451]                           quietly = TRUE)
[17:29:40.451]                         if (has_future) {
[17:29:40.451]                           ns <- base::getNamespace("future")
[17:29:40.451]                           version <- ns[[".package"]][["version"]]
[17:29:40.451]                           if (is.null(version)) 
[17:29:40.451]                             version <- utils::packageVersion("future")
[17:29:40.451]                         }
[17:29:40.451]                         else {
[17:29:40.451]                           version <- NULL
[17:29:40.451]                         }
[17:29:40.451]                         if (!has_future || version < "1.8.0") {
[17:29:40.451]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:40.451]                             "", base::R.version$version.string), 
[17:29:40.451]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:40.451]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:40.451]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:40.451]                               "release", "version")], collapse = " "), 
[17:29:40.451]                             hostname = base::Sys.info()[["nodename"]])
[17:29:40.451]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:40.451]                             info)
[17:29:40.451]                           info <- base::paste(info, collapse = "; ")
[17:29:40.451]                           if (!has_future) {
[17:29:40.451]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:40.451]                               info)
[17:29:40.451]                           }
[17:29:40.451]                           else {
[17:29:40.451]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:40.451]                               info, version)
[17:29:40.451]                           }
[17:29:40.451]                           base::stop(msg)
[17:29:40.451]                         }
[17:29:40.451]                       })
[17:29:40.451]                     }
[17:29:40.451]                     ...future.strategy.old <- future::plan("list")
[17:29:40.451]                     options(future.plan = NULL)
[17:29:40.451]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.451]                     future::plan("default", .cleanup = FALSE, 
[17:29:40.451]                       .init = FALSE)
[17:29:40.451]                   }
[17:29:40.451]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[17:29:40.451]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[17:29:40.451]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[17:29:40.451]                 }
[17:29:40.451]                 ...future.workdir <- getwd()
[17:29:40.451]             }
[17:29:40.451]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:40.451]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:40.451]         }
[17:29:40.451]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:40.451]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:40.451]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:40.451]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:40.451]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:40.451]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:40.451]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:40.451]             base::names(...future.oldOptions))
[17:29:40.451]     }
[17:29:40.451]     if (FALSE) {
[17:29:40.451]     }
[17:29:40.451]     else {
[17:29:40.451]         if (TRUE) {
[17:29:40.451]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:40.451]                 open = "w")
[17:29:40.451]         }
[17:29:40.451]         else {
[17:29:40.451]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:40.451]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:40.451]         }
[17:29:40.451]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:40.451]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:40.451]             base::sink(type = "output", split = FALSE)
[17:29:40.451]             base::close(...future.stdout)
[17:29:40.451]         }, add = TRUE)
[17:29:40.451]     }
[17:29:40.451]     ...future.frame <- base::sys.nframe()
[17:29:40.451]     ...future.conditions <- base::list()
[17:29:40.451]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:40.451]     if (FALSE) {
[17:29:40.451]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:40.451]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:40.451]     }
[17:29:40.451]     ...future.result <- base::tryCatch({
[17:29:40.451]         base::withCallingHandlers({
[17:29:40.451]             ...future.value <- base::withVisible(base::local({
[17:29:40.451]                 sample(x, size = 1L)
[17:29:40.451]             }))
[17:29:40.451]             future::FutureResult(value = ...future.value$value, 
[17:29:40.451]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.451]                   ...future.rng), globalenv = if (FALSE) 
[17:29:40.451]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:40.451]                     ...future.globalenv.names))
[17:29:40.451]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:40.451]         }, condition = base::local({
[17:29:40.451]             c <- base::c
[17:29:40.451]             inherits <- base::inherits
[17:29:40.451]             invokeRestart <- base::invokeRestart
[17:29:40.451]             length <- base::length
[17:29:40.451]             list <- base::list
[17:29:40.451]             seq.int <- base::seq.int
[17:29:40.451]             signalCondition <- base::signalCondition
[17:29:40.451]             sys.calls <- base::sys.calls
[17:29:40.451]             `[[` <- base::`[[`
[17:29:40.451]             `+` <- base::`+`
[17:29:40.451]             `<<-` <- base::`<<-`
[17:29:40.451]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:40.451]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:40.451]                   3L)]
[17:29:40.451]             }
[17:29:40.451]             function(cond) {
[17:29:40.451]                 is_error <- inherits(cond, "error")
[17:29:40.451]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:40.451]                   NULL)
[17:29:40.451]                 if (is_error) {
[17:29:40.451]                   sessionInformation <- function() {
[17:29:40.451]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:40.451]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:40.451]                       search = base::search(), system = base::Sys.info())
[17:29:40.451]                   }
[17:29:40.451]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.451]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:40.451]                     cond$call), session = sessionInformation(), 
[17:29:40.451]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:40.451]                   signalCondition(cond)
[17:29:40.451]                 }
[17:29:40.451]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:40.451]                 "immediateCondition"))) {
[17:29:40.451]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:40.451]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.451]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:40.451]                   if (TRUE && !signal) {
[17:29:40.451]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.451]                     {
[17:29:40.451]                       inherits <- base::inherits
[17:29:40.451]                       invokeRestart <- base::invokeRestart
[17:29:40.451]                       is.null <- base::is.null
[17:29:40.451]                       muffled <- FALSE
[17:29:40.451]                       if (inherits(cond, "message")) {
[17:29:40.451]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.451]                         if (muffled) 
[17:29:40.451]                           invokeRestart("muffleMessage")
[17:29:40.451]                       }
[17:29:40.451]                       else if (inherits(cond, "warning")) {
[17:29:40.451]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.451]                         if (muffled) 
[17:29:40.451]                           invokeRestart("muffleWarning")
[17:29:40.451]                       }
[17:29:40.451]                       else if (inherits(cond, "condition")) {
[17:29:40.451]                         if (!is.null(pattern)) {
[17:29:40.451]                           computeRestarts <- base::computeRestarts
[17:29:40.451]                           grepl <- base::grepl
[17:29:40.451]                           restarts <- computeRestarts(cond)
[17:29:40.451]                           for (restart in restarts) {
[17:29:40.451]                             name <- restart$name
[17:29:40.451]                             if (is.null(name)) 
[17:29:40.451]                               next
[17:29:40.451]                             if (!grepl(pattern, name)) 
[17:29:40.451]                               next
[17:29:40.451]                             invokeRestart(restart)
[17:29:40.451]                             muffled <- TRUE
[17:29:40.451]                             break
[17:29:40.451]                           }
[17:29:40.451]                         }
[17:29:40.451]                       }
[17:29:40.451]                       invisible(muffled)
[17:29:40.451]                     }
[17:29:40.451]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.451]                   }
[17:29:40.451]                 }
[17:29:40.451]                 else {
[17:29:40.451]                   if (TRUE) {
[17:29:40.451]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.451]                     {
[17:29:40.451]                       inherits <- base::inherits
[17:29:40.451]                       invokeRestart <- base::invokeRestart
[17:29:40.451]                       is.null <- base::is.null
[17:29:40.451]                       muffled <- FALSE
[17:29:40.451]                       if (inherits(cond, "message")) {
[17:29:40.451]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.451]                         if (muffled) 
[17:29:40.451]                           invokeRestart("muffleMessage")
[17:29:40.451]                       }
[17:29:40.451]                       else if (inherits(cond, "warning")) {
[17:29:40.451]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.451]                         if (muffled) 
[17:29:40.451]                           invokeRestart("muffleWarning")
[17:29:40.451]                       }
[17:29:40.451]                       else if (inherits(cond, "condition")) {
[17:29:40.451]                         if (!is.null(pattern)) {
[17:29:40.451]                           computeRestarts <- base::computeRestarts
[17:29:40.451]                           grepl <- base::grepl
[17:29:40.451]                           restarts <- computeRestarts(cond)
[17:29:40.451]                           for (restart in restarts) {
[17:29:40.451]                             name <- restart$name
[17:29:40.451]                             if (is.null(name)) 
[17:29:40.451]                               next
[17:29:40.451]                             if (!grepl(pattern, name)) 
[17:29:40.451]                               next
[17:29:40.451]                             invokeRestart(restart)
[17:29:40.451]                             muffled <- TRUE
[17:29:40.451]                             break
[17:29:40.451]                           }
[17:29:40.451]                         }
[17:29:40.451]                       }
[17:29:40.451]                       invisible(muffled)
[17:29:40.451]                     }
[17:29:40.451]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.451]                   }
[17:29:40.451]                 }
[17:29:40.451]             }
[17:29:40.451]         }))
[17:29:40.451]     }, error = function(ex) {
[17:29:40.451]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:40.451]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.451]                 ...future.rng), started = ...future.startTime, 
[17:29:40.451]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:40.451]             version = "1.8"), class = "FutureResult")
[17:29:40.451]     }, finally = {
[17:29:40.451]         if (!identical(...future.workdir, getwd())) 
[17:29:40.451]             setwd(...future.workdir)
[17:29:40.451]         {
[17:29:40.451]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:40.451]                 ...future.oldOptions$nwarnings <- NULL
[17:29:40.451]             }
[17:29:40.451]             base::options(...future.oldOptions)
[17:29:40.451]             if (.Platform$OS.type == "windows") {
[17:29:40.451]                 old_names <- names(...future.oldEnvVars)
[17:29:40.451]                 envs <- base::Sys.getenv()
[17:29:40.451]                 names <- names(envs)
[17:29:40.451]                 common <- intersect(names, old_names)
[17:29:40.451]                 added <- setdiff(names, old_names)
[17:29:40.451]                 removed <- setdiff(old_names, names)
[17:29:40.451]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:40.451]                   envs[common]]
[17:29:40.451]                 NAMES <- toupper(changed)
[17:29:40.451]                 args <- list()
[17:29:40.451]                 for (kk in seq_along(NAMES)) {
[17:29:40.451]                   name <- changed[[kk]]
[17:29:40.451]                   NAME <- NAMES[[kk]]
[17:29:40.451]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.451]                     next
[17:29:40.451]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.451]                 }
[17:29:40.451]                 NAMES <- toupper(added)
[17:29:40.451]                 for (kk in seq_along(NAMES)) {
[17:29:40.451]                   name <- added[[kk]]
[17:29:40.451]                   NAME <- NAMES[[kk]]
[17:29:40.451]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.451]                     next
[17:29:40.451]                   args[[name]] <- ""
[17:29:40.451]                 }
[17:29:40.451]                 NAMES <- toupper(removed)
[17:29:40.451]                 for (kk in seq_along(NAMES)) {
[17:29:40.451]                   name <- removed[[kk]]
[17:29:40.451]                   NAME <- NAMES[[kk]]
[17:29:40.451]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.451]                     next
[17:29:40.451]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.451]                 }
[17:29:40.451]                 if (length(args) > 0) 
[17:29:40.451]                   base::do.call(base::Sys.setenv, args = args)
[17:29:40.451]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:40.451]             }
[17:29:40.451]             else {
[17:29:40.451]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:40.451]             }
[17:29:40.451]             {
[17:29:40.451]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:40.451]                   0L) {
[17:29:40.451]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:40.451]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:40.451]                   base::options(opts)
[17:29:40.451]                 }
[17:29:40.451]                 {
[17:29:40.451]                   {
[17:29:40.451]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:40.451]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:40.451]                     -1344458670L), envir = base::globalenv(), 
[17:29:40.451]                       inherits = FALSE)
[17:29:40.451]                     NULL
[17:29:40.451]                   }
[17:29:40.451]                   options(future.plan = NULL)
[17:29:40.451]                   if (is.na(NA_character_)) 
[17:29:40.451]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.451]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:40.451]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:40.451]                     .init = FALSE)
[17:29:40.451]                 }
[17:29:40.451]             }
[17:29:40.451]         }
[17:29:40.451]     })
[17:29:40.451]     if (TRUE) {
[17:29:40.451]         base::sink(type = "output", split = FALSE)
[17:29:40.451]         if (TRUE) {
[17:29:40.451]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:40.451]         }
[17:29:40.451]         else {
[17:29:40.451]             ...future.result["stdout"] <- base::list(NULL)
[17:29:40.451]         }
[17:29:40.451]         base::close(...future.stdout)
[17:29:40.451]         ...future.stdout <- NULL
[17:29:40.451]     }
[17:29:40.451]     ...future.result$conditions <- ...future.conditions
[17:29:40.451]     ...future.result$finished <- base::Sys.time()
[17:29:40.451]     ...future.result
[17:29:40.451] }
[17:29:40.458] assign_globals() ...
[17:29:40.458] List of 1
[17:29:40.458]  $ x: int [1:4] 0 1 2 3
[17:29:40.458]  - attr(*, "where")=List of 1
[17:29:40.458]   ..$ x:<environment: R_EmptyEnv> 
[17:29:40.458]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:40.458]  - attr(*, "resolved")= logi FALSE
[17:29:40.458]  - attr(*, "total_size")= int 133
[17:29:40.458]  - attr(*, "already-done")= logi TRUE
[17:29:40.463] - copied 'x' to environment
[17:29:40.463] assign_globals() ... done
[17:29:40.464] plan(): Setting new future strategy stack:
[17:29:40.464] List of future strategies:
[17:29:40.464] 1. sequential:
[17:29:40.464]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.464]    - tweaked: FALSE
[17:29:40.464]    - call: NULL
[17:29:40.465] plan(): nbrOfWorkers() = 1
[17:29:40.467] plan(): Setting new future strategy stack:
[17:29:40.467] List of future strategies:
[17:29:40.467] 1. sequential:
[17:29:40.467]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.467]    - tweaked: FALSE
[17:29:40.467]    - call: plan(strategy)
[17:29:40.468] plan(): nbrOfWorkers() = 1
[17:29:40.469] SequentialFuture started (and completed)
[17:29:40.469] - Launch lazy future ... done
[17:29:40.469] run() for 'SequentialFuture' ... done
[17:29:40.470] getGlobalsAndPackages() ...
[17:29:40.470] Searching for globals...
[17:29:40.475] - globals found: [3] '{', 'sample', 'x'
[17:29:40.475] Searching for globals ... DONE
[17:29:40.475] Resolving globals: FALSE
[17:29:40.476] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:40.477] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:40.477] - globals: [1] 'x'
[17:29:40.477] 
[17:29:40.478] getGlobalsAndPackages() ... DONE
[17:29:40.478] run() for 'Future' ...
[17:29:40.479] - state: 'created'
[17:29:40.479] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:40.480] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.480] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:40.480]   - Field: 'label'
[17:29:40.481]   - Field: 'local'
[17:29:40.481]   - Field: 'owner'
[17:29:40.481]   - Field: 'envir'
[17:29:40.482]   - Field: 'packages'
[17:29:40.482]   - Field: 'gc'
[17:29:40.482]   - Field: 'conditions'
[17:29:40.483]   - Field: 'expr'
[17:29:40.483]   - Field: 'uuid'
[17:29:40.483]   - Field: 'seed'
[17:29:40.484]   - Field: 'version'
[17:29:40.484]   - Field: 'result'
[17:29:40.484]   - Field: 'asynchronous'
[17:29:40.485]   - Field: 'calls'
[17:29:40.485]   - Field: 'globals'
[17:29:40.485]   - Field: 'stdout'
[17:29:40.486]   - Field: 'earlySignal'
[17:29:40.486]   - Field: 'lazy'
[17:29:40.486]   - Field: 'state'
[17:29:40.487] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:40.487] - Launch lazy future ...
[17:29:40.487] Packages needed by the future expression (n = 0): <none>
[17:29:40.488] Packages needed by future strategies (n = 0): <none>
[17:29:40.489] {
[17:29:40.489]     {
[17:29:40.489]         {
[17:29:40.489]             ...future.startTime <- base::Sys.time()
[17:29:40.489]             {
[17:29:40.489]                 {
[17:29:40.489]                   {
[17:29:40.489]                     {
[17:29:40.489]                       base::local({
[17:29:40.489]                         has_future <- base::requireNamespace("future", 
[17:29:40.489]                           quietly = TRUE)
[17:29:40.489]                         if (has_future) {
[17:29:40.489]                           ns <- base::getNamespace("future")
[17:29:40.489]                           version <- ns[[".package"]][["version"]]
[17:29:40.489]                           if (is.null(version)) 
[17:29:40.489]                             version <- utils::packageVersion("future")
[17:29:40.489]                         }
[17:29:40.489]                         else {
[17:29:40.489]                           version <- NULL
[17:29:40.489]                         }
[17:29:40.489]                         if (!has_future || version < "1.8.0") {
[17:29:40.489]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:40.489]                             "", base::R.version$version.string), 
[17:29:40.489]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:40.489]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:40.489]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:40.489]                               "release", "version")], collapse = " "), 
[17:29:40.489]                             hostname = base::Sys.info()[["nodename"]])
[17:29:40.489]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:40.489]                             info)
[17:29:40.489]                           info <- base::paste(info, collapse = "; ")
[17:29:40.489]                           if (!has_future) {
[17:29:40.489]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:40.489]                               info)
[17:29:40.489]                           }
[17:29:40.489]                           else {
[17:29:40.489]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:40.489]                               info, version)
[17:29:40.489]                           }
[17:29:40.489]                           base::stop(msg)
[17:29:40.489]                         }
[17:29:40.489]                       })
[17:29:40.489]                     }
[17:29:40.489]                     ...future.strategy.old <- future::plan("list")
[17:29:40.489]                     options(future.plan = NULL)
[17:29:40.489]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.489]                     future::plan("default", .cleanup = FALSE, 
[17:29:40.489]                       .init = FALSE)
[17:29:40.489]                   }
[17:29:40.489]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[17:29:40.489]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[17:29:40.489]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[17:29:40.489]                 }
[17:29:40.489]                 ...future.workdir <- getwd()
[17:29:40.489]             }
[17:29:40.489]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:40.489]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:40.489]         }
[17:29:40.489]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:40.489]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:40.489]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:40.489]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:40.489]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:40.489]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:40.489]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:40.489]             base::names(...future.oldOptions))
[17:29:40.489]     }
[17:29:40.489]     if (FALSE) {
[17:29:40.489]     }
[17:29:40.489]     else {
[17:29:40.489]         if (TRUE) {
[17:29:40.489]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:40.489]                 open = "w")
[17:29:40.489]         }
[17:29:40.489]         else {
[17:29:40.489]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:40.489]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:40.489]         }
[17:29:40.489]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:40.489]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:40.489]             base::sink(type = "output", split = FALSE)
[17:29:40.489]             base::close(...future.stdout)
[17:29:40.489]         }, add = TRUE)
[17:29:40.489]     }
[17:29:40.489]     ...future.frame <- base::sys.nframe()
[17:29:40.489]     ...future.conditions <- base::list()
[17:29:40.489]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:40.489]     if (FALSE) {
[17:29:40.489]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:40.489]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:40.489]     }
[17:29:40.489]     ...future.result <- base::tryCatch({
[17:29:40.489]         base::withCallingHandlers({
[17:29:40.489]             ...future.value <- base::withVisible(base::local({
[17:29:40.489]                 sample(x, size = 1L)
[17:29:40.489]             }))
[17:29:40.489]             future::FutureResult(value = ...future.value$value, 
[17:29:40.489]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.489]                   ...future.rng), globalenv = if (FALSE) 
[17:29:40.489]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:40.489]                     ...future.globalenv.names))
[17:29:40.489]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:40.489]         }, condition = base::local({
[17:29:40.489]             c <- base::c
[17:29:40.489]             inherits <- base::inherits
[17:29:40.489]             invokeRestart <- base::invokeRestart
[17:29:40.489]             length <- base::length
[17:29:40.489]             list <- base::list
[17:29:40.489]             seq.int <- base::seq.int
[17:29:40.489]             signalCondition <- base::signalCondition
[17:29:40.489]             sys.calls <- base::sys.calls
[17:29:40.489]             `[[` <- base::`[[`
[17:29:40.489]             `+` <- base::`+`
[17:29:40.489]             `<<-` <- base::`<<-`
[17:29:40.489]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:40.489]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:40.489]                   3L)]
[17:29:40.489]             }
[17:29:40.489]             function(cond) {
[17:29:40.489]                 is_error <- inherits(cond, "error")
[17:29:40.489]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:40.489]                   NULL)
[17:29:40.489]                 if (is_error) {
[17:29:40.489]                   sessionInformation <- function() {
[17:29:40.489]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:40.489]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:40.489]                       search = base::search(), system = base::Sys.info())
[17:29:40.489]                   }
[17:29:40.489]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.489]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:40.489]                     cond$call), session = sessionInformation(), 
[17:29:40.489]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:40.489]                   signalCondition(cond)
[17:29:40.489]                 }
[17:29:40.489]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:40.489]                 "immediateCondition"))) {
[17:29:40.489]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:40.489]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.489]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:40.489]                   if (TRUE && !signal) {
[17:29:40.489]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.489]                     {
[17:29:40.489]                       inherits <- base::inherits
[17:29:40.489]                       invokeRestart <- base::invokeRestart
[17:29:40.489]                       is.null <- base::is.null
[17:29:40.489]                       muffled <- FALSE
[17:29:40.489]                       if (inherits(cond, "message")) {
[17:29:40.489]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.489]                         if (muffled) 
[17:29:40.489]                           invokeRestart("muffleMessage")
[17:29:40.489]                       }
[17:29:40.489]                       else if (inherits(cond, "warning")) {
[17:29:40.489]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.489]                         if (muffled) 
[17:29:40.489]                           invokeRestart("muffleWarning")
[17:29:40.489]                       }
[17:29:40.489]                       else if (inherits(cond, "condition")) {
[17:29:40.489]                         if (!is.null(pattern)) {
[17:29:40.489]                           computeRestarts <- base::computeRestarts
[17:29:40.489]                           grepl <- base::grepl
[17:29:40.489]                           restarts <- computeRestarts(cond)
[17:29:40.489]                           for (restart in restarts) {
[17:29:40.489]                             name <- restart$name
[17:29:40.489]                             if (is.null(name)) 
[17:29:40.489]                               next
[17:29:40.489]                             if (!grepl(pattern, name)) 
[17:29:40.489]                               next
[17:29:40.489]                             invokeRestart(restart)
[17:29:40.489]                             muffled <- TRUE
[17:29:40.489]                             break
[17:29:40.489]                           }
[17:29:40.489]                         }
[17:29:40.489]                       }
[17:29:40.489]                       invisible(muffled)
[17:29:40.489]                     }
[17:29:40.489]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.489]                   }
[17:29:40.489]                 }
[17:29:40.489]                 else {
[17:29:40.489]                   if (TRUE) {
[17:29:40.489]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.489]                     {
[17:29:40.489]                       inherits <- base::inherits
[17:29:40.489]                       invokeRestart <- base::invokeRestart
[17:29:40.489]                       is.null <- base::is.null
[17:29:40.489]                       muffled <- FALSE
[17:29:40.489]                       if (inherits(cond, "message")) {
[17:29:40.489]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.489]                         if (muffled) 
[17:29:40.489]                           invokeRestart("muffleMessage")
[17:29:40.489]                       }
[17:29:40.489]                       else if (inherits(cond, "warning")) {
[17:29:40.489]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.489]                         if (muffled) 
[17:29:40.489]                           invokeRestart("muffleWarning")
[17:29:40.489]                       }
[17:29:40.489]                       else if (inherits(cond, "condition")) {
[17:29:40.489]                         if (!is.null(pattern)) {
[17:29:40.489]                           computeRestarts <- base::computeRestarts
[17:29:40.489]                           grepl <- base::grepl
[17:29:40.489]                           restarts <- computeRestarts(cond)
[17:29:40.489]                           for (restart in restarts) {
[17:29:40.489]                             name <- restart$name
[17:29:40.489]                             if (is.null(name)) 
[17:29:40.489]                               next
[17:29:40.489]                             if (!grepl(pattern, name)) 
[17:29:40.489]                               next
[17:29:40.489]                             invokeRestart(restart)
[17:29:40.489]                             muffled <- TRUE
[17:29:40.489]                             break
[17:29:40.489]                           }
[17:29:40.489]                         }
[17:29:40.489]                       }
[17:29:40.489]                       invisible(muffled)
[17:29:40.489]                     }
[17:29:40.489]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.489]                   }
[17:29:40.489]                 }
[17:29:40.489]             }
[17:29:40.489]         }))
[17:29:40.489]     }, error = function(ex) {
[17:29:40.489]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:40.489]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.489]                 ...future.rng), started = ...future.startTime, 
[17:29:40.489]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:40.489]             version = "1.8"), class = "FutureResult")
[17:29:40.489]     }, finally = {
[17:29:40.489]         if (!identical(...future.workdir, getwd())) 
[17:29:40.489]             setwd(...future.workdir)
[17:29:40.489]         {
[17:29:40.489]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:40.489]                 ...future.oldOptions$nwarnings <- NULL
[17:29:40.489]             }
[17:29:40.489]             base::options(...future.oldOptions)
[17:29:40.489]             if (.Platform$OS.type == "windows") {
[17:29:40.489]                 old_names <- names(...future.oldEnvVars)
[17:29:40.489]                 envs <- base::Sys.getenv()
[17:29:40.489]                 names <- names(envs)
[17:29:40.489]                 common <- intersect(names, old_names)
[17:29:40.489]                 added <- setdiff(names, old_names)
[17:29:40.489]                 removed <- setdiff(old_names, names)
[17:29:40.489]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:40.489]                   envs[common]]
[17:29:40.489]                 NAMES <- toupper(changed)
[17:29:40.489]                 args <- list()
[17:29:40.489]                 for (kk in seq_along(NAMES)) {
[17:29:40.489]                   name <- changed[[kk]]
[17:29:40.489]                   NAME <- NAMES[[kk]]
[17:29:40.489]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.489]                     next
[17:29:40.489]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.489]                 }
[17:29:40.489]                 NAMES <- toupper(added)
[17:29:40.489]                 for (kk in seq_along(NAMES)) {
[17:29:40.489]                   name <- added[[kk]]
[17:29:40.489]                   NAME <- NAMES[[kk]]
[17:29:40.489]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.489]                     next
[17:29:40.489]                   args[[name]] <- ""
[17:29:40.489]                 }
[17:29:40.489]                 NAMES <- toupper(removed)
[17:29:40.489]                 for (kk in seq_along(NAMES)) {
[17:29:40.489]                   name <- removed[[kk]]
[17:29:40.489]                   NAME <- NAMES[[kk]]
[17:29:40.489]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.489]                     next
[17:29:40.489]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.489]                 }
[17:29:40.489]                 if (length(args) > 0) 
[17:29:40.489]                   base::do.call(base::Sys.setenv, args = args)
[17:29:40.489]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:40.489]             }
[17:29:40.489]             else {
[17:29:40.489]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:40.489]             }
[17:29:40.489]             {
[17:29:40.489]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:40.489]                   0L) {
[17:29:40.489]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:40.489]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:40.489]                   base::options(opts)
[17:29:40.489]                 }
[17:29:40.489]                 {
[17:29:40.489]                   {
[17:29:40.489]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:40.489]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:40.489]                     -1344458670L), envir = base::globalenv(), 
[17:29:40.489]                       inherits = FALSE)
[17:29:40.489]                     NULL
[17:29:40.489]                   }
[17:29:40.489]                   options(future.plan = NULL)
[17:29:40.489]                   if (is.na(NA_character_)) 
[17:29:40.489]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.489]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:40.489]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:40.489]                     .init = FALSE)
[17:29:40.489]                 }
[17:29:40.489]             }
[17:29:40.489]         }
[17:29:40.489]     })
[17:29:40.489]     if (TRUE) {
[17:29:40.489]         base::sink(type = "output", split = FALSE)
[17:29:40.489]         if (TRUE) {
[17:29:40.489]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:40.489]         }
[17:29:40.489]         else {
[17:29:40.489]             ...future.result["stdout"] <- base::list(NULL)
[17:29:40.489]         }
[17:29:40.489]         base::close(...future.stdout)
[17:29:40.489]         ...future.stdout <- NULL
[17:29:40.489]     }
[17:29:40.489]     ...future.result$conditions <- ...future.conditions
[17:29:40.489]     ...future.result$finished <- base::Sys.time()
[17:29:40.489]     ...future.result
[17:29:40.489] }
[17:29:40.495] assign_globals() ...
[17:29:40.495] List of 1
[17:29:40.495]  $ x: int [1:4] 0 1 2 3
[17:29:40.495]  - attr(*, "where")=List of 1
[17:29:40.495]   ..$ x:<environment: R_EmptyEnv> 
[17:29:40.495]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:40.495]  - attr(*, "resolved")= logi FALSE
[17:29:40.495]  - attr(*, "total_size")= int 133
[17:29:40.495]  - attr(*, "already-done")= logi TRUE
[17:29:40.501] - copied 'x' to environment
[17:29:40.501] assign_globals() ... done
[17:29:40.502] plan(): Setting new future strategy stack:
[17:29:40.502] List of future strategies:
[17:29:40.502] 1. sequential:
[17:29:40.502]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.502]    - tweaked: FALSE
[17:29:40.502]    - call: NULL
[17:29:40.504] plan(): nbrOfWorkers() = 1
[17:29:40.506] plan(): Setting new future strategy stack:
[17:29:40.506] List of future strategies:
[17:29:40.506] 1. sequential:
[17:29:40.506]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.506]    - tweaked: FALSE
[17:29:40.506]    - call: plan(strategy)
[17:29:40.507] plan(): nbrOfWorkers() = 1
[17:29:40.508] SequentialFuture started (and completed)
[17:29:40.508] - Launch lazy future ... done
[17:29:40.509] run() for 'SequentialFuture' ... done
[17:29:40.509] getGlobalsAndPackages() ...
[17:29:40.509] Searching for globals...
[17:29:40.512] - globals found: [3] '{', 'sample', 'x'
[17:29:40.512] Searching for globals ... DONE
[17:29:40.512] Resolving globals: FALSE
[17:29:40.513] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:40.514] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:40.514] - globals: [1] 'x'
[17:29:40.515] 
[17:29:40.515] getGlobalsAndPackages() ... DONE
[17:29:40.515] run() for 'Future' ...
[17:29:40.516] - state: 'created'
[17:29:40.516] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:40.517] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.517] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:40.518]   - Field: 'label'
[17:29:40.518]   - Field: 'local'
[17:29:40.518]   - Field: 'owner'
[17:29:40.519]   - Field: 'envir'
[17:29:40.519]   - Field: 'packages'
[17:29:40.519]   - Field: 'gc'
[17:29:40.520]   - Field: 'conditions'
[17:29:40.520]   - Field: 'expr'
[17:29:40.520]   - Field: 'uuid'
[17:29:40.521]   - Field: 'seed'
[17:29:40.521]   - Field: 'version'
[17:29:40.521]   - Field: 'result'
[17:29:40.522]   - Field: 'asynchronous'
[17:29:40.522]   - Field: 'calls'
[17:29:40.522]   - Field: 'globals'
[17:29:40.523]   - Field: 'stdout'
[17:29:40.523]   - Field: 'earlySignal'
[17:29:40.524]   - Field: 'lazy'
[17:29:40.524]   - Field: 'state'
[17:29:40.524] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:40.525] - Launch lazy future ...
[17:29:40.525] Packages needed by the future expression (n = 0): <none>
[17:29:40.525] Packages needed by future strategies (n = 0): <none>
[17:29:40.527] {
[17:29:40.527]     {
[17:29:40.527]         {
[17:29:40.527]             ...future.startTime <- base::Sys.time()
[17:29:40.527]             {
[17:29:40.527]                 {
[17:29:40.527]                   {
[17:29:40.527]                     {
[17:29:40.527]                       base::local({
[17:29:40.527]                         has_future <- base::requireNamespace("future", 
[17:29:40.527]                           quietly = TRUE)
[17:29:40.527]                         if (has_future) {
[17:29:40.527]                           ns <- base::getNamespace("future")
[17:29:40.527]                           version <- ns[[".package"]][["version"]]
[17:29:40.527]                           if (is.null(version)) 
[17:29:40.527]                             version <- utils::packageVersion("future")
[17:29:40.527]                         }
[17:29:40.527]                         else {
[17:29:40.527]                           version <- NULL
[17:29:40.527]                         }
[17:29:40.527]                         if (!has_future || version < "1.8.0") {
[17:29:40.527]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:40.527]                             "", base::R.version$version.string), 
[17:29:40.527]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:40.527]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:40.527]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:40.527]                               "release", "version")], collapse = " "), 
[17:29:40.527]                             hostname = base::Sys.info()[["nodename"]])
[17:29:40.527]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:40.527]                             info)
[17:29:40.527]                           info <- base::paste(info, collapse = "; ")
[17:29:40.527]                           if (!has_future) {
[17:29:40.527]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:40.527]                               info)
[17:29:40.527]                           }
[17:29:40.527]                           else {
[17:29:40.527]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:40.527]                               info, version)
[17:29:40.527]                           }
[17:29:40.527]                           base::stop(msg)
[17:29:40.527]                         }
[17:29:40.527]                       })
[17:29:40.527]                     }
[17:29:40.527]                     ...future.strategy.old <- future::plan("list")
[17:29:40.527]                     options(future.plan = NULL)
[17:29:40.527]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.527]                     future::plan("default", .cleanup = FALSE, 
[17:29:40.527]                       .init = FALSE)
[17:29:40.527]                   }
[17:29:40.527]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[17:29:40.527]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[17:29:40.527]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[17:29:40.527]                 }
[17:29:40.527]                 ...future.workdir <- getwd()
[17:29:40.527]             }
[17:29:40.527]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:40.527]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:40.527]         }
[17:29:40.527]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:40.527]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:40.527]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:40.527]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:40.527]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:40.527]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:40.527]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:40.527]             base::names(...future.oldOptions))
[17:29:40.527]     }
[17:29:40.527]     if (FALSE) {
[17:29:40.527]     }
[17:29:40.527]     else {
[17:29:40.527]         if (TRUE) {
[17:29:40.527]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:40.527]                 open = "w")
[17:29:40.527]         }
[17:29:40.527]         else {
[17:29:40.527]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:40.527]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:40.527]         }
[17:29:40.527]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:40.527]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:40.527]             base::sink(type = "output", split = FALSE)
[17:29:40.527]             base::close(...future.stdout)
[17:29:40.527]         }, add = TRUE)
[17:29:40.527]     }
[17:29:40.527]     ...future.frame <- base::sys.nframe()
[17:29:40.527]     ...future.conditions <- base::list()
[17:29:40.527]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:40.527]     if (FALSE) {
[17:29:40.527]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:40.527]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:40.527]     }
[17:29:40.527]     ...future.result <- base::tryCatch({
[17:29:40.527]         base::withCallingHandlers({
[17:29:40.527]             ...future.value <- base::withVisible(base::local({
[17:29:40.527]                 sample(x, size = 1L)
[17:29:40.527]             }))
[17:29:40.527]             future::FutureResult(value = ...future.value$value, 
[17:29:40.527]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.527]                   ...future.rng), globalenv = if (FALSE) 
[17:29:40.527]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:40.527]                     ...future.globalenv.names))
[17:29:40.527]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:40.527]         }, condition = base::local({
[17:29:40.527]             c <- base::c
[17:29:40.527]             inherits <- base::inherits
[17:29:40.527]             invokeRestart <- base::invokeRestart
[17:29:40.527]             length <- base::length
[17:29:40.527]             list <- base::list
[17:29:40.527]             seq.int <- base::seq.int
[17:29:40.527]             signalCondition <- base::signalCondition
[17:29:40.527]             sys.calls <- base::sys.calls
[17:29:40.527]             `[[` <- base::`[[`
[17:29:40.527]             `+` <- base::`+`
[17:29:40.527]             `<<-` <- base::`<<-`
[17:29:40.527]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:40.527]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:40.527]                   3L)]
[17:29:40.527]             }
[17:29:40.527]             function(cond) {
[17:29:40.527]                 is_error <- inherits(cond, "error")
[17:29:40.527]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:40.527]                   NULL)
[17:29:40.527]                 if (is_error) {
[17:29:40.527]                   sessionInformation <- function() {
[17:29:40.527]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:40.527]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:40.527]                       search = base::search(), system = base::Sys.info())
[17:29:40.527]                   }
[17:29:40.527]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.527]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:40.527]                     cond$call), session = sessionInformation(), 
[17:29:40.527]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:40.527]                   signalCondition(cond)
[17:29:40.527]                 }
[17:29:40.527]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:40.527]                 "immediateCondition"))) {
[17:29:40.527]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:40.527]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.527]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:40.527]                   if (TRUE && !signal) {
[17:29:40.527]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.527]                     {
[17:29:40.527]                       inherits <- base::inherits
[17:29:40.527]                       invokeRestart <- base::invokeRestart
[17:29:40.527]                       is.null <- base::is.null
[17:29:40.527]                       muffled <- FALSE
[17:29:40.527]                       if (inherits(cond, "message")) {
[17:29:40.527]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.527]                         if (muffled) 
[17:29:40.527]                           invokeRestart("muffleMessage")
[17:29:40.527]                       }
[17:29:40.527]                       else if (inherits(cond, "warning")) {
[17:29:40.527]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.527]                         if (muffled) 
[17:29:40.527]                           invokeRestart("muffleWarning")
[17:29:40.527]                       }
[17:29:40.527]                       else if (inherits(cond, "condition")) {
[17:29:40.527]                         if (!is.null(pattern)) {
[17:29:40.527]                           computeRestarts <- base::computeRestarts
[17:29:40.527]                           grepl <- base::grepl
[17:29:40.527]                           restarts <- computeRestarts(cond)
[17:29:40.527]                           for (restart in restarts) {
[17:29:40.527]                             name <- restart$name
[17:29:40.527]                             if (is.null(name)) 
[17:29:40.527]                               next
[17:29:40.527]                             if (!grepl(pattern, name)) 
[17:29:40.527]                               next
[17:29:40.527]                             invokeRestart(restart)
[17:29:40.527]                             muffled <- TRUE
[17:29:40.527]                             break
[17:29:40.527]                           }
[17:29:40.527]                         }
[17:29:40.527]                       }
[17:29:40.527]                       invisible(muffled)
[17:29:40.527]                     }
[17:29:40.527]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.527]                   }
[17:29:40.527]                 }
[17:29:40.527]                 else {
[17:29:40.527]                   if (TRUE) {
[17:29:40.527]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.527]                     {
[17:29:40.527]                       inherits <- base::inherits
[17:29:40.527]                       invokeRestart <- base::invokeRestart
[17:29:40.527]                       is.null <- base::is.null
[17:29:40.527]                       muffled <- FALSE
[17:29:40.527]                       if (inherits(cond, "message")) {
[17:29:40.527]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.527]                         if (muffled) 
[17:29:40.527]                           invokeRestart("muffleMessage")
[17:29:40.527]                       }
[17:29:40.527]                       else if (inherits(cond, "warning")) {
[17:29:40.527]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.527]                         if (muffled) 
[17:29:40.527]                           invokeRestart("muffleWarning")
[17:29:40.527]                       }
[17:29:40.527]                       else if (inherits(cond, "condition")) {
[17:29:40.527]                         if (!is.null(pattern)) {
[17:29:40.527]                           computeRestarts <- base::computeRestarts
[17:29:40.527]                           grepl <- base::grepl
[17:29:40.527]                           restarts <- computeRestarts(cond)
[17:29:40.527]                           for (restart in restarts) {
[17:29:40.527]                             name <- restart$name
[17:29:40.527]                             if (is.null(name)) 
[17:29:40.527]                               next
[17:29:40.527]                             if (!grepl(pattern, name)) 
[17:29:40.527]                               next
[17:29:40.527]                             invokeRestart(restart)
[17:29:40.527]                             muffled <- TRUE
[17:29:40.527]                             break
[17:29:40.527]                           }
[17:29:40.527]                         }
[17:29:40.527]                       }
[17:29:40.527]                       invisible(muffled)
[17:29:40.527]                     }
[17:29:40.527]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.527]                   }
[17:29:40.527]                 }
[17:29:40.527]             }
[17:29:40.527]         }))
[17:29:40.527]     }, error = function(ex) {
[17:29:40.527]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:40.527]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.527]                 ...future.rng), started = ...future.startTime, 
[17:29:40.527]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:40.527]             version = "1.8"), class = "FutureResult")
[17:29:40.527]     }, finally = {
[17:29:40.527]         if (!identical(...future.workdir, getwd())) 
[17:29:40.527]             setwd(...future.workdir)
[17:29:40.527]         {
[17:29:40.527]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:40.527]                 ...future.oldOptions$nwarnings <- NULL
[17:29:40.527]             }
[17:29:40.527]             base::options(...future.oldOptions)
[17:29:40.527]             if (.Platform$OS.type == "windows") {
[17:29:40.527]                 old_names <- names(...future.oldEnvVars)
[17:29:40.527]                 envs <- base::Sys.getenv()
[17:29:40.527]                 names <- names(envs)
[17:29:40.527]                 common <- intersect(names, old_names)
[17:29:40.527]                 added <- setdiff(names, old_names)
[17:29:40.527]                 removed <- setdiff(old_names, names)
[17:29:40.527]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:40.527]                   envs[common]]
[17:29:40.527]                 NAMES <- toupper(changed)
[17:29:40.527]                 args <- list()
[17:29:40.527]                 for (kk in seq_along(NAMES)) {
[17:29:40.527]                   name <- changed[[kk]]
[17:29:40.527]                   NAME <- NAMES[[kk]]
[17:29:40.527]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.527]                     next
[17:29:40.527]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.527]                 }
[17:29:40.527]                 NAMES <- toupper(added)
[17:29:40.527]                 for (kk in seq_along(NAMES)) {
[17:29:40.527]                   name <- added[[kk]]
[17:29:40.527]                   NAME <- NAMES[[kk]]
[17:29:40.527]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.527]                     next
[17:29:40.527]                   args[[name]] <- ""
[17:29:40.527]                 }
[17:29:40.527]                 NAMES <- toupper(removed)
[17:29:40.527]                 for (kk in seq_along(NAMES)) {
[17:29:40.527]                   name <- removed[[kk]]
[17:29:40.527]                   NAME <- NAMES[[kk]]
[17:29:40.527]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.527]                     next
[17:29:40.527]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.527]                 }
[17:29:40.527]                 if (length(args) > 0) 
[17:29:40.527]                   base::do.call(base::Sys.setenv, args = args)
[17:29:40.527]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:40.527]             }
[17:29:40.527]             else {
[17:29:40.527]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:40.527]             }
[17:29:40.527]             {
[17:29:40.527]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:40.527]                   0L) {
[17:29:40.527]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:40.527]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:40.527]                   base::options(opts)
[17:29:40.527]                 }
[17:29:40.527]                 {
[17:29:40.527]                   {
[17:29:40.527]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:40.527]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:40.527]                     -1344458670L), envir = base::globalenv(), 
[17:29:40.527]                       inherits = FALSE)
[17:29:40.527]                     NULL
[17:29:40.527]                   }
[17:29:40.527]                   options(future.plan = NULL)
[17:29:40.527]                   if (is.na(NA_character_)) 
[17:29:40.527]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.527]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:40.527]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:40.527]                     .init = FALSE)
[17:29:40.527]                 }
[17:29:40.527]             }
[17:29:40.527]         }
[17:29:40.527]     })
[17:29:40.527]     if (TRUE) {
[17:29:40.527]         base::sink(type = "output", split = FALSE)
[17:29:40.527]         if (TRUE) {
[17:29:40.527]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:40.527]         }
[17:29:40.527]         else {
[17:29:40.527]             ...future.result["stdout"] <- base::list(NULL)
[17:29:40.527]         }
[17:29:40.527]         base::close(...future.stdout)
[17:29:40.527]         ...future.stdout <- NULL
[17:29:40.527]     }
[17:29:40.527]     ...future.result$conditions <- ...future.conditions
[17:29:40.527]     ...future.result$finished <- base::Sys.time()
[17:29:40.527]     ...future.result
[17:29:40.527] }
[17:29:40.534] assign_globals() ...
[17:29:40.534] List of 1
[17:29:40.534]  $ x: int [1:4] 0 1 2 3
[17:29:40.534]  - attr(*, "where")=List of 1
[17:29:40.534]   ..$ x:<environment: R_EmptyEnv> 
[17:29:40.534]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:40.534]  - attr(*, "resolved")= logi FALSE
[17:29:40.534]  - attr(*, "total_size")= int 133
[17:29:40.534]  - attr(*, "already-done")= logi TRUE
[17:29:40.543] - copied 'x' to environment
[17:29:40.543] assign_globals() ... done
[17:29:40.544] plan(): Setting new future strategy stack:
[17:29:40.544] List of future strategies:
[17:29:40.544] 1. sequential:
[17:29:40.544]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.544]    - tweaked: FALSE
[17:29:40.544]    - call: NULL
[17:29:40.545] plan(): nbrOfWorkers() = 1
[17:29:40.547] plan(): Setting new future strategy stack:
[17:29:40.548] List of future strategies:
[17:29:40.548] 1. sequential:
[17:29:40.548]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.548]    - tweaked: FALSE
[17:29:40.548]    - call: plan(strategy)
[17:29:40.549] plan(): nbrOfWorkers() = 1
[17:29:40.549] SequentialFuture started (and completed)
[17:29:40.550] - Launch lazy future ... done
[17:29:40.550] run() for 'SequentialFuture' ... done
[17:29:40.551] getGlobalsAndPackages() ...
[17:29:40.551] Searching for globals...
[17:29:40.553] - globals found: [3] '{', 'sample', 'x'
[17:29:40.553] Searching for globals ... DONE
[17:29:40.554] Resolving globals: FALSE
[17:29:40.554] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:40.555] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:40.555] - globals: [1] 'x'
[17:29:40.556] 
[17:29:40.556] getGlobalsAndPackages() ... DONE
[17:29:40.557] run() for 'Future' ...
[17:29:40.557] - state: 'created'
[17:29:40.557] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:40.558] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.558] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:40.559]   - Field: 'label'
[17:29:40.559]   - Field: 'local'
[17:29:40.560]   - Field: 'owner'
[17:29:40.560]   - Field: 'envir'
[17:29:40.560]   - Field: 'packages'
[17:29:40.560]   - Field: 'gc'
[17:29:40.561]   - Field: 'conditions'
[17:29:40.561]   - Field: 'expr'
[17:29:40.561]   - Field: 'uuid'
[17:29:40.562]   - Field: 'seed'
[17:29:40.562]   - Field: 'version'
[17:29:40.562]   - Field: 'result'
[17:29:40.563]   - Field: 'asynchronous'
[17:29:40.563]   - Field: 'calls'
[17:29:40.563]   - Field: 'globals'
[17:29:40.564]   - Field: 'stdout'
[17:29:40.564]   - Field: 'earlySignal'
[17:29:40.564]   - Field: 'lazy'
[17:29:40.565]   - Field: 'state'
[17:29:40.565] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:40.565] - Launch lazy future ...
[17:29:40.566] Packages needed by the future expression (n = 0): <none>
[17:29:40.566] Packages needed by future strategies (n = 0): <none>
[17:29:40.567] {
[17:29:40.567]     {
[17:29:40.567]         {
[17:29:40.567]             ...future.startTime <- base::Sys.time()
[17:29:40.567]             {
[17:29:40.567]                 {
[17:29:40.567]                   {
[17:29:40.567]                     {
[17:29:40.567]                       base::local({
[17:29:40.567]                         has_future <- base::requireNamespace("future", 
[17:29:40.567]                           quietly = TRUE)
[17:29:40.567]                         if (has_future) {
[17:29:40.567]                           ns <- base::getNamespace("future")
[17:29:40.567]                           version <- ns[[".package"]][["version"]]
[17:29:40.567]                           if (is.null(version)) 
[17:29:40.567]                             version <- utils::packageVersion("future")
[17:29:40.567]                         }
[17:29:40.567]                         else {
[17:29:40.567]                           version <- NULL
[17:29:40.567]                         }
[17:29:40.567]                         if (!has_future || version < "1.8.0") {
[17:29:40.567]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:40.567]                             "", base::R.version$version.string), 
[17:29:40.567]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:40.567]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:40.567]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:40.567]                               "release", "version")], collapse = " "), 
[17:29:40.567]                             hostname = base::Sys.info()[["nodename"]])
[17:29:40.567]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:40.567]                             info)
[17:29:40.567]                           info <- base::paste(info, collapse = "; ")
[17:29:40.567]                           if (!has_future) {
[17:29:40.567]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:40.567]                               info)
[17:29:40.567]                           }
[17:29:40.567]                           else {
[17:29:40.567]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:40.567]                               info, version)
[17:29:40.567]                           }
[17:29:40.567]                           base::stop(msg)
[17:29:40.567]                         }
[17:29:40.567]                       })
[17:29:40.567]                     }
[17:29:40.567]                     ...future.strategy.old <- future::plan("list")
[17:29:40.567]                     options(future.plan = NULL)
[17:29:40.567]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.567]                     future::plan("default", .cleanup = FALSE, 
[17:29:40.567]                       .init = FALSE)
[17:29:40.567]                   }
[17:29:40.567]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[17:29:40.567]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[17:29:40.567]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[17:29:40.567]                 }
[17:29:40.567]                 ...future.workdir <- getwd()
[17:29:40.567]             }
[17:29:40.567]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:40.567]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:40.567]         }
[17:29:40.567]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:40.567]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:40.567]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:40.567]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:40.567]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:40.567]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:40.567]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:40.567]             base::names(...future.oldOptions))
[17:29:40.567]     }
[17:29:40.567]     if (FALSE) {
[17:29:40.567]     }
[17:29:40.567]     else {
[17:29:40.567]         if (TRUE) {
[17:29:40.567]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:40.567]                 open = "w")
[17:29:40.567]         }
[17:29:40.567]         else {
[17:29:40.567]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:40.567]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:40.567]         }
[17:29:40.567]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:40.567]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:40.567]             base::sink(type = "output", split = FALSE)
[17:29:40.567]             base::close(...future.stdout)
[17:29:40.567]         }, add = TRUE)
[17:29:40.567]     }
[17:29:40.567]     ...future.frame <- base::sys.nframe()
[17:29:40.567]     ...future.conditions <- base::list()
[17:29:40.567]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:40.567]     if (FALSE) {
[17:29:40.567]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:40.567]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:40.567]     }
[17:29:40.567]     ...future.result <- base::tryCatch({
[17:29:40.567]         base::withCallingHandlers({
[17:29:40.567]             ...future.value <- base::withVisible(base::local({
[17:29:40.567]                 sample(x, size = 1L)
[17:29:40.567]             }))
[17:29:40.567]             future::FutureResult(value = ...future.value$value, 
[17:29:40.567]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.567]                   ...future.rng), globalenv = if (FALSE) 
[17:29:40.567]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:40.567]                     ...future.globalenv.names))
[17:29:40.567]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:40.567]         }, condition = base::local({
[17:29:40.567]             c <- base::c
[17:29:40.567]             inherits <- base::inherits
[17:29:40.567]             invokeRestart <- base::invokeRestart
[17:29:40.567]             length <- base::length
[17:29:40.567]             list <- base::list
[17:29:40.567]             seq.int <- base::seq.int
[17:29:40.567]             signalCondition <- base::signalCondition
[17:29:40.567]             sys.calls <- base::sys.calls
[17:29:40.567]             `[[` <- base::`[[`
[17:29:40.567]             `+` <- base::`+`
[17:29:40.567]             `<<-` <- base::`<<-`
[17:29:40.567]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:40.567]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:40.567]                   3L)]
[17:29:40.567]             }
[17:29:40.567]             function(cond) {
[17:29:40.567]                 is_error <- inherits(cond, "error")
[17:29:40.567]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:40.567]                   NULL)
[17:29:40.567]                 if (is_error) {
[17:29:40.567]                   sessionInformation <- function() {
[17:29:40.567]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:40.567]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:40.567]                       search = base::search(), system = base::Sys.info())
[17:29:40.567]                   }
[17:29:40.567]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.567]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:40.567]                     cond$call), session = sessionInformation(), 
[17:29:40.567]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:40.567]                   signalCondition(cond)
[17:29:40.567]                 }
[17:29:40.567]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:40.567]                 "immediateCondition"))) {
[17:29:40.567]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:40.567]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.567]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:40.567]                   if (TRUE && !signal) {
[17:29:40.567]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.567]                     {
[17:29:40.567]                       inherits <- base::inherits
[17:29:40.567]                       invokeRestart <- base::invokeRestart
[17:29:40.567]                       is.null <- base::is.null
[17:29:40.567]                       muffled <- FALSE
[17:29:40.567]                       if (inherits(cond, "message")) {
[17:29:40.567]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.567]                         if (muffled) 
[17:29:40.567]                           invokeRestart("muffleMessage")
[17:29:40.567]                       }
[17:29:40.567]                       else if (inherits(cond, "warning")) {
[17:29:40.567]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.567]                         if (muffled) 
[17:29:40.567]                           invokeRestart("muffleWarning")
[17:29:40.567]                       }
[17:29:40.567]                       else if (inherits(cond, "condition")) {
[17:29:40.567]                         if (!is.null(pattern)) {
[17:29:40.567]                           computeRestarts <- base::computeRestarts
[17:29:40.567]                           grepl <- base::grepl
[17:29:40.567]                           restarts <- computeRestarts(cond)
[17:29:40.567]                           for (restart in restarts) {
[17:29:40.567]                             name <- restart$name
[17:29:40.567]                             if (is.null(name)) 
[17:29:40.567]                               next
[17:29:40.567]                             if (!grepl(pattern, name)) 
[17:29:40.567]                               next
[17:29:40.567]                             invokeRestart(restart)
[17:29:40.567]                             muffled <- TRUE
[17:29:40.567]                             break
[17:29:40.567]                           }
[17:29:40.567]                         }
[17:29:40.567]                       }
[17:29:40.567]                       invisible(muffled)
[17:29:40.567]                     }
[17:29:40.567]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.567]                   }
[17:29:40.567]                 }
[17:29:40.567]                 else {
[17:29:40.567]                   if (TRUE) {
[17:29:40.567]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.567]                     {
[17:29:40.567]                       inherits <- base::inherits
[17:29:40.567]                       invokeRestart <- base::invokeRestart
[17:29:40.567]                       is.null <- base::is.null
[17:29:40.567]                       muffled <- FALSE
[17:29:40.567]                       if (inherits(cond, "message")) {
[17:29:40.567]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.567]                         if (muffled) 
[17:29:40.567]                           invokeRestart("muffleMessage")
[17:29:40.567]                       }
[17:29:40.567]                       else if (inherits(cond, "warning")) {
[17:29:40.567]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.567]                         if (muffled) 
[17:29:40.567]                           invokeRestart("muffleWarning")
[17:29:40.567]                       }
[17:29:40.567]                       else if (inherits(cond, "condition")) {
[17:29:40.567]                         if (!is.null(pattern)) {
[17:29:40.567]                           computeRestarts <- base::computeRestarts
[17:29:40.567]                           grepl <- base::grepl
[17:29:40.567]                           restarts <- computeRestarts(cond)
[17:29:40.567]                           for (restart in restarts) {
[17:29:40.567]                             name <- restart$name
[17:29:40.567]                             if (is.null(name)) 
[17:29:40.567]                               next
[17:29:40.567]                             if (!grepl(pattern, name)) 
[17:29:40.567]                               next
[17:29:40.567]                             invokeRestart(restart)
[17:29:40.567]                             muffled <- TRUE
[17:29:40.567]                             break
[17:29:40.567]                           }
[17:29:40.567]                         }
[17:29:40.567]                       }
[17:29:40.567]                       invisible(muffled)
[17:29:40.567]                     }
[17:29:40.567]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.567]                   }
[17:29:40.567]                 }
[17:29:40.567]             }
[17:29:40.567]         }))
[17:29:40.567]     }, error = function(ex) {
[17:29:40.567]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:40.567]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.567]                 ...future.rng), started = ...future.startTime, 
[17:29:40.567]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:40.567]             version = "1.8"), class = "FutureResult")
[17:29:40.567]     }, finally = {
[17:29:40.567]         if (!identical(...future.workdir, getwd())) 
[17:29:40.567]             setwd(...future.workdir)
[17:29:40.567]         {
[17:29:40.567]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:40.567]                 ...future.oldOptions$nwarnings <- NULL
[17:29:40.567]             }
[17:29:40.567]             base::options(...future.oldOptions)
[17:29:40.567]             if (.Platform$OS.type == "windows") {
[17:29:40.567]                 old_names <- names(...future.oldEnvVars)
[17:29:40.567]                 envs <- base::Sys.getenv()
[17:29:40.567]                 names <- names(envs)
[17:29:40.567]                 common <- intersect(names, old_names)
[17:29:40.567]                 added <- setdiff(names, old_names)
[17:29:40.567]                 removed <- setdiff(old_names, names)
[17:29:40.567]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:40.567]                   envs[common]]
[17:29:40.567]                 NAMES <- toupper(changed)
[17:29:40.567]                 args <- list()
[17:29:40.567]                 for (kk in seq_along(NAMES)) {
[17:29:40.567]                   name <- changed[[kk]]
[17:29:40.567]                   NAME <- NAMES[[kk]]
[17:29:40.567]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.567]                     next
[17:29:40.567]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.567]                 }
[17:29:40.567]                 NAMES <- toupper(added)
[17:29:40.567]                 for (kk in seq_along(NAMES)) {
[17:29:40.567]                   name <- added[[kk]]
[17:29:40.567]                   NAME <- NAMES[[kk]]
[17:29:40.567]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.567]                     next
[17:29:40.567]                   args[[name]] <- ""
[17:29:40.567]                 }
[17:29:40.567]                 NAMES <- toupper(removed)
[17:29:40.567]                 for (kk in seq_along(NAMES)) {
[17:29:40.567]                   name <- removed[[kk]]
[17:29:40.567]                   NAME <- NAMES[[kk]]
[17:29:40.567]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.567]                     next
[17:29:40.567]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.567]                 }
[17:29:40.567]                 if (length(args) > 0) 
[17:29:40.567]                   base::do.call(base::Sys.setenv, args = args)
[17:29:40.567]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:40.567]             }
[17:29:40.567]             else {
[17:29:40.567]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:40.567]             }
[17:29:40.567]             {
[17:29:40.567]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:40.567]                   0L) {
[17:29:40.567]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:40.567]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:40.567]                   base::options(opts)
[17:29:40.567]                 }
[17:29:40.567]                 {
[17:29:40.567]                   {
[17:29:40.567]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:40.567]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:40.567]                     -1344458670L), envir = base::globalenv(), 
[17:29:40.567]                       inherits = FALSE)
[17:29:40.567]                     NULL
[17:29:40.567]                   }
[17:29:40.567]                   options(future.plan = NULL)
[17:29:40.567]                   if (is.na(NA_character_)) 
[17:29:40.567]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.567]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:40.567]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:40.567]                     .init = FALSE)
[17:29:40.567]                 }
[17:29:40.567]             }
[17:29:40.567]         }
[17:29:40.567]     })
[17:29:40.567]     if (TRUE) {
[17:29:40.567]         base::sink(type = "output", split = FALSE)
[17:29:40.567]         if (TRUE) {
[17:29:40.567]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:40.567]         }
[17:29:40.567]         else {
[17:29:40.567]             ...future.result["stdout"] <- base::list(NULL)
[17:29:40.567]         }
[17:29:40.567]         base::close(...future.stdout)
[17:29:40.567]         ...future.stdout <- NULL
[17:29:40.567]     }
[17:29:40.567]     ...future.result$conditions <- ...future.conditions
[17:29:40.567]     ...future.result$finished <- base::Sys.time()
[17:29:40.567]     ...future.result
[17:29:40.567] }
[17:29:40.574] assign_globals() ...
[17:29:40.575] List of 1
[17:29:40.575]  $ x: int [1:4] 0 1 2 3
[17:29:40.575]  - attr(*, "where")=List of 1
[17:29:40.575]   ..$ x:<environment: R_EmptyEnv> 
[17:29:40.575]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:40.575]  - attr(*, "resolved")= logi FALSE
[17:29:40.575]  - attr(*, "total_size")= int 133
[17:29:40.575]  - attr(*, "already-done")= logi TRUE
[17:29:40.581] - copied 'x' to environment
[17:29:40.581] assign_globals() ... done
[17:29:40.582] plan(): Setting new future strategy stack:
[17:29:40.582] List of future strategies:
[17:29:40.582] 1. sequential:
[17:29:40.582]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.582]    - tweaked: FALSE
[17:29:40.582]    - call: NULL
[17:29:40.583] plan(): nbrOfWorkers() = 1
[17:29:40.585] plan(): Setting new future strategy stack:
[17:29:40.586] List of future strategies:
[17:29:40.586] 1. sequential:
[17:29:40.586]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.586]    - tweaked: FALSE
[17:29:40.586]    - call: plan(strategy)
[17:29:40.587] plan(): nbrOfWorkers() = 1
[17:29:40.587] SequentialFuture started (and completed)
[17:29:40.587] - Launch lazy future ... done
[17:29:40.588] run() for 'SequentialFuture' ... done
[17:29:40.588] resolve() on list ...
[17:29:40.588]  recursive: 0
[17:29:40.589]  length: 4
[17:29:40.589] 
[17:29:40.589] resolved() for 'SequentialFuture' ...
[17:29:40.589] - state: 'finished'
[17:29:40.590] - run: TRUE
[17:29:40.590] - result: 'FutureResult'
[17:29:40.590] resolved() for 'SequentialFuture' ... done
[17:29:40.591] Future #1
[17:29:40.591] signalConditionsASAP(SequentialFuture, pos=1) ...
[17:29:40.591] - nx: 4
[17:29:40.592] - relay: TRUE
[17:29:40.592] - stdout: TRUE
[17:29:40.592] - signal: TRUE
[17:29:40.592] - resignal: FALSE
[17:29:40.593] - force: TRUE
[17:29:40.593] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:40.596] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:40.596]  - until=1
[17:29:40.596]  - relaying element #1
[17:29:40.597] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:40.597] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:40.598] signalConditionsASAP(SequentialFuture, pos=1) ... done
[17:29:40.598]  length: 3 (resolved future 1)
[17:29:40.598] resolved() for 'SequentialFuture' ...
[17:29:40.599] - state: 'finished'
[17:29:40.599] - run: TRUE
[17:29:40.600] - result: 'FutureResult'
[17:29:40.600] resolved() for 'SequentialFuture' ... done
[17:29:40.600] Future #2
[17:29:40.601] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:29:40.601] - nx: 4
[17:29:40.601] - relay: TRUE
[17:29:40.602] - stdout: TRUE
[17:29:40.602] - signal: TRUE
[17:29:40.602] - resignal: FALSE
[17:29:40.603] - force: TRUE
[17:29:40.603] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:40.603] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:40.604]  - until=2
[17:29:40.604]  - relaying element #2
[17:29:40.604] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:40.605] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:40.605] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:29:40.605]  length: 2 (resolved future 2)
[17:29:40.606] resolved() for 'SequentialFuture' ...
[17:29:40.606] - state: 'finished'
[17:29:40.606] - run: TRUE
[17:29:40.607] - result: 'FutureResult'
[17:29:40.607] resolved() for 'SequentialFuture' ... done
[17:29:40.607] Future #3
[17:29:40.608] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:29:40.608] - nx: 4
[17:29:40.609] - relay: TRUE
[17:29:40.609] - stdout: TRUE
[17:29:40.609] - signal: TRUE
[17:29:40.609] - resignal: FALSE
[17:29:40.610] - force: TRUE
[17:29:40.610] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:40.610] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:40.611]  - until=3
[17:29:40.611]  - relaying element #3
[17:29:40.612] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:40.612] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:40.612] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:29:40.613]  length: 1 (resolved future 3)
[17:29:40.613] resolved() for 'SequentialFuture' ...
[17:29:40.613] - state: 'finished'
[17:29:40.614] - run: TRUE
[17:29:40.614] - result: 'FutureResult'
[17:29:40.614] resolved() for 'SequentialFuture' ... done
[17:29:40.615] Future #4
[17:29:40.615] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:29:40.616] - nx: 4
[17:29:40.616] - relay: TRUE
[17:29:40.616] - stdout: TRUE
[17:29:40.616] - signal: TRUE
[17:29:40.617] - resignal: FALSE
[17:29:40.617] - force: TRUE
[17:29:40.617] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:40.618] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:40.618]  - until=4
[17:29:40.618]  - relaying element #4
[17:29:40.619] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.619] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.619] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:29:40.620]  length: 0 (resolved future 4)
[17:29:40.620] Relaying remaining futures
[17:29:40.620] signalConditionsASAP(NULL, pos=0) ...
[17:29:40.621] - nx: 4
[17:29:40.621] - relay: TRUE
[17:29:40.621] - stdout: TRUE
[17:29:40.622] - signal: TRUE
[17:29:40.622] - resignal: FALSE
[17:29:40.622] - force: TRUE
[17:29:40.623] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.623] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:29:40.623] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.624] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.624] signalConditionsASAP(NULL, pos=0) ... done
[17:29:40.624] resolve() on list ... DONE
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[17:29:40.626] getGlobalsAndPackages() ...
[17:29:40.626] Searching for globals...
[17:29:40.628] - globals found: [3] '{', 'sample', 'x'
[17:29:40.629] Searching for globals ... DONE
[17:29:40.629] Resolving globals: FALSE
[17:29:40.630] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:40.631] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:40.631] - globals: [1] 'x'
[17:29:40.632] 
[17:29:40.632] getGlobalsAndPackages() ... DONE
[17:29:40.633] run() for 'Future' ...
[17:29:40.633] - state: 'created'
[17:29:40.633] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:40.634] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.634] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:40.635]   - Field: 'label'
[17:29:40.635]   - Field: 'local'
[17:29:40.635]   - Field: 'owner'
[17:29:40.636]   - Field: 'envir'
[17:29:40.636]   - Field: 'packages'
[17:29:40.636]   - Field: 'gc'
[17:29:40.637]   - Field: 'conditions'
[17:29:40.637]   - Field: 'expr'
[17:29:40.638]   - Field: 'uuid'
[17:29:40.638]   - Field: 'seed'
[17:29:40.638]   - Field: 'version'
[17:29:40.639]   - Field: 'result'
[17:29:40.639]   - Field: 'asynchronous'
[17:29:40.639]   - Field: 'calls'
[17:29:40.640]   - Field: 'globals'
[17:29:40.640]   - Field: 'stdout'
[17:29:40.640]   - Field: 'earlySignal'
[17:29:40.641]   - Field: 'lazy'
[17:29:40.641]   - Field: 'state'
[17:29:40.641] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:40.642] - Launch lazy future ...
[17:29:40.642] Packages needed by the future expression (n = 0): <none>
[17:29:40.642] Packages needed by future strategies (n = 0): <none>
[17:29:40.644] {
[17:29:40.644]     {
[17:29:40.644]         {
[17:29:40.644]             ...future.startTime <- base::Sys.time()
[17:29:40.644]             {
[17:29:40.644]                 {
[17:29:40.644]                   {
[17:29:40.644]                     {
[17:29:40.644]                       base::local({
[17:29:40.644]                         has_future <- base::requireNamespace("future", 
[17:29:40.644]                           quietly = TRUE)
[17:29:40.644]                         if (has_future) {
[17:29:40.644]                           ns <- base::getNamespace("future")
[17:29:40.644]                           version <- ns[[".package"]][["version"]]
[17:29:40.644]                           if (is.null(version)) 
[17:29:40.644]                             version <- utils::packageVersion("future")
[17:29:40.644]                         }
[17:29:40.644]                         else {
[17:29:40.644]                           version <- NULL
[17:29:40.644]                         }
[17:29:40.644]                         if (!has_future || version < "1.8.0") {
[17:29:40.644]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:40.644]                             "", base::R.version$version.string), 
[17:29:40.644]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:40.644]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:40.644]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:40.644]                               "release", "version")], collapse = " "), 
[17:29:40.644]                             hostname = base::Sys.info()[["nodename"]])
[17:29:40.644]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:40.644]                             info)
[17:29:40.644]                           info <- base::paste(info, collapse = "; ")
[17:29:40.644]                           if (!has_future) {
[17:29:40.644]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:40.644]                               info)
[17:29:40.644]                           }
[17:29:40.644]                           else {
[17:29:40.644]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:40.644]                               info, version)
[17:29:40.644]                           }
[17:29:40.644]                           base::stop(msg)
[17:29:40.644]                         }
[17:29:40.644]                       })
[17:29:40.644]                     }
[17:29:40.644]                     ...future.strategy.old <- future::plan("list")
[17:29:40.644]                     options(future.plan = NULL)
[17:29:40.644]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.644]                     future::plan("default", .cleanup = FALSE, 
[17:29:40.644]                       .init = FALSE)
[17:29:40.644]                   }
[17:29:40.644]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[17:29:40.644]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[17:29:40.644]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[17:29:40.644]                 }
[17:29:40.644]                 ...future.workdir <- getwd()
[17:29:40.644]             }
[17:29:40.644]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:40.644]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:40.644]         }
[17:29:40.644]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:40.644]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:40.644]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:40.644]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:40.644]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:40.644]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:40.644]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:40.644]             base::names(...future.oldOptions))
[17:29:40.644]     }
[17:29:40.644]     if (FALSE) {
[17:29:40.644]     }
[17:29:40.644]     else {
[17:29:40.644]         if (TRUE) {
[17:29:40.644]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:40.644]                 open = "w")
[17:29:40.644]         }
[17:29:40.644]         else {
[17:29:40.644]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:40.644]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:40.644]         }
[17:29:40.644]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:40.644]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:40.644]             base::sink(type = "output", split = FALSE)
[17:29:40.644]             base::close(...future.stdout)
[17:29:40.644]         }, add = TRUE)
[17:29:40.644]     }
[17:29:40.644]     ...future.frame <- base::sys.nframe()
[17:29:40.644]     ...future.conditions <- base::list()
[17:29:40.644]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:40.644]     if (FALSE) {
[17:29:40.644]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:40.644]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:40.644]     }
[17:29:40.644]     ...future.result <- base::tryCatch({
[17:29:40.644]         base::withCallingHandlers({
[17:29:40.644]             ...future.value <- base::withVisible(base::local({
[17:29:40.644]                 sample(x, size = 1L)
[17:29:40.644]             }))
[17:29:40.644]             future::FutureResult(value = ...future.value$value, 
[17:29:40.644]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.644]                   ...future.rng), globalenv = if (FALSE) 
[17:29:40.644]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:40.644]                     ...future.globalenv.names))
[17:29:40.644]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:40.644]         }, condition = base::local({
[17:29:40.644]             c <- base::c
[17:29:40.644]             inherits <- base::inherits
[17:29:40.644]             invokeRestart <- base::invokeRestart
[17:29:40.644]             length <- base::length
[17:29:40.644]             list <- base::list
[17:29:40.644]             seq.int <- base::seq.int
[17:29:40.644]             signalCondition <- base::signalCondition
[17:29:40.644]             sys.calls <- base::sys.calls
[17:29:40.644]             `[[` <- base::`[[`
[17:29:40.644]             `+` <- base::`+`
[17:29:40.644]             `<<-` <- base::`<<-`
[17:29:40.644]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:40.644]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:40.644]                   3L)]
[17:29:40.644]             }
[17:29:40.644]             function(cond) {
[17:29:40.644]                 is_error <- inherits(cond, "error")
[17:29:40.644]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:40.644]                   NULL)
[17:29:40.644]                 if (is_error) {
[17:29:40.644]                   sessionInformation <- function() {
[17:29:40.644]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:40.644]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:40.644]                       search = base::search(), system = base::Sys.info())
[17:29:40.644]                   }
[17:29:40.644]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.644]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:40.644]                     cond$call), session = sessionInformation(), 
[17:29:40.644]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:40.644]                   signalCondition(cond)
[17:29:40.644]                 }
[17:29:40.644]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:40.644]                 "immediateCondition"))) {
[17:29:40.644]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:40.644]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.644]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:40.644]                   if (TRUE && !signal) {
[17:29:40.644]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.644]                     {
[17:29:40.644]                       inherits <- base::inherits
[17:29:40.644]                       invokeRestart <- base::invokeRestart
[17:29:40.644]                       is.null <- base::is.null
[17:29:40.644]                       muffled <- FALSE
[17:29:40.644]                       if (inherits(cond, "message")) {
[17:29:40.644]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.644]                         if (muffled) 
[17:29:40.644]                           invokeRestart("muffleMessage")
[17:29:40.644]                       }
[17:29:40.644]                       else if (inherits(cond, "warning")) {
[17:29:40.644]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.644]                         if (muffled) 
[17:29:40.644]                           invokeRestart("muffleWarning")
[17:29:40.644]                       }
[17:29:40.644]                       else if (inherits(cond, "condition")) {
[17:29:40.644]                         if (!is.null(pattern)) {
[17:29:40.644]                           computeRestarts <- base::computeRestarts
[17:29:40.644]                           grepl <- base::grepl
[17:29:40.644]                           restarts <- computeRestarts(cond)
[17:29:40.644]                           for (restart in restarts) {
[17:29:40.644]                             name <- restart$name
[17:29:40.644]                             if (is.null(name)) 
[17:29:40.644]                               next
[17:29:40.644]                             if (!grepl(pattern, name)) 
[17:29:40.644]                               next
[17:29:40.644]                             invokeRestart(restart)
[17:29:40.644]                             muffled <- TRUE
[17:29:40.644]                             break
[17:29:40.644]                           }
[17:29:40.644]                         }
[17:29:40.644]                       }
[17:29:40.644]                       invisible(muffled)
[17:29:40.644]                     }
[17:29:40.644]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.644]                   }
[17:29:40.644]                 }
[17:29:40.644]                 else {
[17:29:40.644]                   if (TRUE) {
[17:29:40.644]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.644]                     {
[17:29:40.644]                       inherits <- base::inherits
[17:29:40.644]                       invokeRestart <- base::invokeRestart
[17:29:40.644]                       is.null <- base::is.null
[17:29:40.644]                       muffled <- FALSE
[17:29:40.644]                       if (inherits(cond, "message")) {
[17:29:40.644]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.644]                         if (muffled) 
[17:29:40.644]                           invokeRestart("muffleMessage")
[17:29:40.644]                       }
[17:29:40.644]                       else if (inherits(cond, "warning")) {
[17:29:40.644]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.644]                         if (muffled) 
[17:29:40.644]                           invokeRestart("muffleWarning")
[17:29:40.644]                       }
[17:29:40.644]                       else if (inherits(cond, "condition")) {
[17:29:40.644]                         if (!is.null(pattern)) {
[17:29:40.644]                           computeRestarts <- base::computeRestarts
[17:29:40.644]                           grepl <- base::grepl
[17:29:40.644]                           restarts <- computeRestarts(cond)
[17:29:40.644]                           for (restart in restarts) {
[17:29:40.644]                             name <- restart$name
[17:29:40.644]                             if (is.null(name)) 
[17:29:40.644]                               next
[17:29:40.644]                             if (!grepl(pattern, name)) 
[17:29:40.644]                               next
[17:29:40.644]                             invokeRestart(restart)
[17:29:40.644]                             muffled <- TRUE
[17:29:40.644]                             break
[17:29:40.644]                           }
[17:29:40.644]                         }
[17:29:40.644]                       }
[17:29:40.644]                       invisible(muffled)
[17:29:40.644]                     }
[17:29:40.644]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.644]                   }
[17:29:40.644]                 }
[17:29:40.644]             }
[17:29:40.644]         }))
[17:29:40.644]     }, error = function(ex) {
[17:29:40.644]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:40.644]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.644]                 ...future.rng), started = ...future.startTime, 
[17:29:40.644]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:40.644]             version = "1.8"), class = "FutureResult")
[17:29:40.644]     }, finally = {
[17:29:40.644]         if (!identical(...future.workdir, getwd())) 
[17:29:40.644]             setwd(...future.workdir)
[17:29:40.644]         {
[17:29:40.644]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:40.644]                 ...future.oldOptions$nwarnings <- NULL
[17:29:40.644]             }
[17:29:40.644]             base::options(...future.oldOptions)
[17:29:40.644]             if (.Platform$OS.type == "windows") {
[17:29:40.644]                 old_names <- names(...future.oldEnvVars)
[17:29:40.644]                 envs <- base::Sys.getenv()
[17:29:40.644]                 names <- names(envs)
[17:29:40.644]                 common <- intersect(names, old_names)
[17:29:40.644]                 added <- setdiff(names, old_names)
[17:29:40.644]                 removed <- setdiff(old_names, names)
[17:29:40.644]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:40.644]                   envs[common]]
[17:29:40.644]                 NAMES <- toupper(changed)
[17:29:40.644]                 args <- list()
[17:29:40.644]                 for (kk in seq_along(NAMES)) {
[17:29:40.644]                   name <- changed[[kk]]
[17:29:40.644]                   NAME <- NAMES[[kk]]
[17:29:40.644]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.644]                     next
[17:29:40.644]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.644]                 }
[17:29:40.644]                 NAMES <- toupper(added)
[17:29:40.644]                 for (kk in seq_along(NAMES)) {
[17:29:40.644]                   name <- added[[kk]]
[17:29:40.644]                   NAME <- NAMES[[kk]]
[17:29:40.644]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.644]                     next
[17:29:40.644]                   args[[name]] <- ""
[17:29:40.644]                 }
[17:29:40.644]                 NAMES <- toupper(removed)
[17:29:40.644]                 for (kk in seq_along(NAMES)) {
[17:29:40.644]                   name <- removed[[kk]]
[17:29:40.644]                   NAME <- NAMES[[kk]]
[17:29:40.644]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.644]                     next
[17:29:40.644]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.644]                 }
[17:29:40.644]                 if (length(args) > 0) 
[17:29:40.644]                   base::do.call(base::Sys.setenv, args = args)
[17:29:40.644]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:40.644]             }
[17:29:40.644]             else {
[17:29:40.644]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:40.644]             }
[17:29:40.644]             {
[17:29:40.644]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:40.644]                   0L) {
[17:29:40.644]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:40.644]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:40.644]                   base::options(opts)
[17:29:40.644]                 }
[17:29:40.644]                 {
[17:29:40.644]                   {
[17:29:40.644]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:40.644]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:40.644]                     -1344458670L), envir = base::globalenv(), 
[17:29:40.644]                       inherits = FALSE)
[17:29:40.644]                     NULL
[17:29:40.644]                   }
[17:29:40.644]                   options(future.plan = NULL)
[17:29:40.644]                   if (is.na(NA_character_)) 
[17:29:40.644]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.644]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:40.644]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:40.644]                     .init = FALSE)
[17:29:40.644]                 }
[17:29:40.644]             }
[17:29:40.644]         }
[17:29:40.644]     })
[17:29:40.644]     if (TRUE) {
[17:29:40.644]         base::sink(type = "output", split = FALSE)
[17:29:40.644]         if (TRUE) {
[17:29:40.644]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:40.644]         }
[17:29:40.644]         else {
[17:29:40.644]             ...future.result["stdout"] <- base::list(NULL)
[17:29:40.644]         }
[17:29:40.644]         base::close(...future.stdout)
[17:29:40.644]         ...future.stdout <- NULL
[17:29:40.644]     }
[17:29:40.644]     ...future.result$conditions <- ...future.conditions
[17:29:40.644]     ...future.result$finished <- base::Sys.time()
[17:29:40.644]     ...future.result
[17:29:40.644] }
[17:29:40.650] assign_globals() ...
[17:29:40.651] List of 1
[17:29:40.651]  $ x: int [1:4] 0 1 2 3
[17:29:40.651]  - attr(*, "where")=List of 1
[17:29:40.651]   ..$ x:<environment: R_EmptyEnv> 
[17:29:40.651]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:40.651]  - attr(*, "resolved")= logi FALSE
[17:29:40.651]  - attr(*, "total_size")= int 133
[17:29:40.651]  - attr(*, "already-done")= logi TRUE
[17:29:40.658] - copied 'x' to environment
[17:29:40.659] assign_globals() ... done
[17:29:40.659] plan(): Setting new future strategy stack:
[17:29:40.660] List of future strategies:
[17:29:40.660] 1. sequential:
[17:29:40.660]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.660]    - tweaked: FALSE
[17:29:40.660]    - call: NULL
[17:29:40.661] plan(): nbrOfWorkers() = 1
[17:29:40.663] plan(): Setting new future strategy stack:
[17:29:40.663] List of future strategies:
[17:29:40.663] 1. sequential:
[17:29:40.663]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.663]    - tweaked: FALSE
[17:29:40.663]    - call: plan(strategy)
[17:29:40.664] plan(): nbrOfWorkers() = 1
[17:29:40.665] SequentialFuture started (and completed)
[17:29:40.665] - Launch lazy future ... done
[17:29:40.665] run() for 'SequentialFuture' ... done
[17:29:40.666] getGlobalsAndPackages() ...
[17:29:40.666] Searching for globals...
[17:29:40.668] - globals found: [3] '{', 'sample', 'x'
[17:29:40.669] Searching for globals ... DONE
[17:29:40.669] Resolving globals: FALSE
[17:29:40.670] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:40.671] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:40.671] - globals: [1] 'x'
[17:29:40.671] 
[17:29:40.672] getGlobalsAndPackages() ... DONE
[17:29:40.672] run() for 'Future' ...
[17:29:40.673] - state: 'created'
[17:29:40.673] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:40.674] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.674] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:40.674]   - Field: 'label'
[17:29:40.675]   - Field: 'local'
[17:29:40.675]   - Field: 'owner'
[17:29:40.676]   - Field: 'envir'
[17:29:40.676]   - Field: 'packages'
[17:29:40.676]   - Field: 'gc'
[17:29:40.677]   - Field: 'conditions'
[17:29:40.677]   - Field: 'expr'
[17:29:40.677]   - Field: 'uuid'
[17:29:40.678]   - Field: 'seed'
[17:29:40.678]   - Field: 'version'
[17:29:40.678]   - Field: 'result'
[17:29:40.679]   - Field: 'asynchronous'
[17:29:40.679]   - Field: 'calls'
[17:29:40.679]   - Field: 'globals'
[17:29:40.680]   - Field: 'stdout'
[17:29:40.680]   - Field: 'earlySignal'
[17:29:40.680]   - Field: 'lazy'
[17:29:40.681]   - Field: 'state'
[17:29:40.681] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:40.681] - Launch lazy future ...
[17:29:40.682] Packages needed by the future expression (n = 0): <none>
[17:29:40.682] Packages needed by future strategies (n = 0): <none>
[17:29:40.683] {
[17:29:40.683]     {
[17:29:40.683]         {
[17:29:40.683]             ...future.startTime <- base::Sys.time()
[17:29:40.683]             {
[17:29:40.683]                 {
[17:29:40.683]                   {
[17:29:40.683]                     {
[17:29:40.683]                       base::local({
[17:29:40.683]                         has_future <- base::requireNamespace("future", 
[17:29:40.683]                           quietly = TRUE)
[17:29:40.683]                         if (has_future) {
[17:29:40.683]                           ns <- base::getNamespace("future")
[17:29:40.683]                           version <- ns[[".package"]][["version"]]
[17:29:40.683]                           if (is.null(version)) 
[17:29:40.683]                             version <- utils::packageVersion("future")
[17:29:40.683]                         }
[17:29:40.683]                         else {
[17:29:40.683]                           version <- NULL
[17:29:40.683]                         }
[17:29:40.683]                         if (!has_future || version < "1.8.0") {
[17:29:40.683]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:40.683]                             "", base::R.version$version.string), 
[17:29:40.683]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:40.683]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:40.683]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:40.683]                               "release", "version")], collapse = " "), 
[17:29:40.683]                             hostname = base::Sys.info()[["nodename"]])
[17:29:40.683]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:40.683]                             info)
[17:29:40.683]                           info <- base::paste(info, collapse = "; ")
[17:29:40.683]                           if (!has_future) {
[17:29:40.683]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:40.683]                               info)
[17:29:40.683]                           }
[17:29:40.683]                           else {
[17:29:40.683]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:40.683]                               info, version)
[17:29:40.683]                           }
[17:29:40.683]                           base::stop(msg)
[17:29:40.683]                         }
[17:29:40.683]                       })
[17:29:40.683]                     }
[17:29:40.683]                     ...future.strategy.old <- future::plan("list")
[17:29:40.683]                     options(future.plan = NULL)
[17:29:40.683]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.683]                     future::plan("default", .cleanup = FALSE, 
[17:29:40.683]                       .init = FALSE)
[17:29:40.683]                   }
[17:29:40.683]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[17:29:40.683]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[17:29:40.683]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[17:29:40.683]                 }
[17:29:40.683]                 ...future.workdir <- getwd()
[17:29:40.683]             }
[17:29:40.683]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:40.683]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:40.683]         }
[17:29:40.683]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:40.683]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:40.683]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:40.683]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:40.683]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:40.683]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:40.683]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:40.683]             base::names(...future.oldOptions))
[17:29:40.683]     }
[17:29:40.683]     if (FALSE) {
[17:29:40.683]     }
[17:29:40.683]     else {
[17:29:40.683]         if (TRUE) {
[17:29:40.683]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:40.683]                 open = "w")
[17:29:40.683]         }
[17:29:40.683]         else {
[17:29:40.683]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:40.683]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:40.683]         }
[17:29:40.683]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:40.683]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:40.683]             base::sink(type = "output", split = FALSE)
[17:29:40.683]             base::close(...future.stdout)
[17:29:40.683]         }, add = TRUE)
[17:29:40.683]     }
[17:29:40.683]     ...future.frame <- base::sys.nframe()
[17:29:40.683]     ...future.conditions <- base::list()
[17:29:40.683]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:40.683]     if (FALSE) {
[17:29:40.683]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:40.683]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:40.683]     }
[17:29:40.683]     ...future.result <- base::tryCatch({
[17:29:40.683]         base::withCallingHandlers({
[17:29:40.683]             ...future.value <- base::withVisible(base::local({
[17:29:40.683]                 sample(x, size = 1L)
[17:29:40.683]             }))
[17:29:40.683]             future::FutureResult(value = ...future.value$value, 
[17:29:40.683]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.683]                   ...future.rng), globalenv = if (FALSE) 
[17:29:40.683]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:40.683]                     ...future.globalenv.names))
[17:29:40.683]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:40.683]         }, condition = base::local({
[17:29:40.683]             c <- base::c
[17:29:40.683]             inherits <- base::inherits
[17:29:40.683]             invokeRestart <- base::invokeRestart
[17:29:40.683]             length <- base::length
[17:29:40.683]             list <- base::list
[17:29:40.683]             seq.int <- base::seq.int
[17:29:40.683]             signalCondition <- base::signalCondition
[17:29:40.683]             sys.calls <- base::sys.calls
[17:29:40.683]             `[[` <- base::`[[`
[17:29:40.683]             `+` <- base::`+`
[17:29:40.683]             `<<-` <- base::`<<-`
[17:29:40.683]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:40.683]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:40.683]                   3L)]
[17:29:40.683]             }
[17:29:40.683]             function(cond) {
[17:29:40.683]                 is_error <- inherits(cond, "error")
[17:29:40.683]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:40.683]                   NULL)
[17:29:40.683]                 if (is_error) {
[17:29:40.683]                   sessionInformation <- function() {
[17:29:40.683]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:40.683]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:40.683]                       search = base::search(), system = base::Sys.info())
[17:29:40.683]                   }
[17:29:40.683]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.683]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:40.683]                     cond$call), session = sessionInformation(), 
[17:29:40.683]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:40.683]                   signalCondition(cond)
[17:29:40.683]                 }
[17:29:40.683]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:40.683]                 "immediateCondition"))) {
[17:29:40.683]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:40.683]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.683]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:40.683]                   if (TRUE && !signal) {
[17:29:40.683]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.683]                     {
[17:29:40.683]                       inherits <- base::inherits
[17:29:40.683]                       invokeRestart <- base::invokeRestart
[17:29:40.683]                       is.null <- base::is.null
[17:29:40.683]                       muffled <- FALSE
[17:29:40.683]                       if (inherits(cond, "message")) {
[17:29:40.683]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.683]                         if (muffled) 
[17:29:40.683]                           invokeRestart("muffleMessage")
[17:29:40.683]                       }
[17:29:40.683]                       else if (inherits(cond, "warning")) {
[17:29:40.683]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.683]                         if (muffled) 
[17:29:40.683]                           invokeRestart("muffleWarning")
[17:29:40.683]                       }
[17:29:40.683]                       else if (inherits(cond, "condition")) {
[17:29:40.683]                         if (!is.null(pattern)) {
[17:29:40.683]                           computeRestarts <- base::computeRestarts
[17:29:40.683]                           grepl <- base::grepl
[17:29:40.683]                           restarts <- computeRestarts(cond)
[17:29:40.683]                           for (restart in restarts) {
[17:29:40.683]                             name <- restart$name
[17:29:40.683]                             if (is.null(name)) 
[17:29:40.683]                               next
[17:29:40.683]                             if (!grepl(pattern, name)) 
[17:29:40.683]                               next
[17:29:40.683]                             invokeRestart(restart)
[17:29:40.683]                             muffled <- TRUE
[17:29:40.683]                             break
[17:29:40.683]                           }
[17:29:40.683]                         }
[17:29:40.683]                       }
[17:29:40.683]                       invisible(muffled)
[17:29:40.683]                     }
[17:29:40.683]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.683]                   }
[17:29:40.683]                 }
[17:29:40.683]                 else {
[17:29:40.683]                   if (TRUE) {
[17:29:40.683]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.683]                     {
[17:29:40.683]                       inherits <- base::inherits
[17:29:40.683]                       invokeRestart <- base::invokeRestart
[17:29:40.683]                       is.null <- base::is.null
[17:29:40.683]                       muffled <- FALSE
[17:29:40.683]                       if (inherits(cond, "message")) {
[17:29:40.683]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.683]                         if (muffled) 
[17:29:40.683]                           invokeRestart("muffleMessage")
[17:29:40.683]                       }
[17:29:40.683]                       else if (inherits(cond, "warning")) {
[17:29:40.683]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.683]                         if (muffled) 
[17:29:40.683]                           invokeRestart("muffleWarning")
[17:29:40.683]                       }
[17:29:40.683]                       else if (inherits(cond, "condition")) {
[17:29:40.683]                         if (!is.null(pattern)) {
[17:29:40.683]                           computeRestarts <- base::computeRestarts
[17:29:40.683]                           grepl <- base::grepl
[17:29:40.683]                           restarts <- computeRestarts(cond)
[17:29:40.683]                           for (restart in restarts) {
[17:29:40.683]                             name <- restart$name
[17:29:40.683]                             if (is.null(name)) 
[17:29:40.683]                               next
[17:29:40.683]                             if (!grepl(pattern, name)) 
[17:29:40.683]                               next
[17:29:40.683]                             invokeRestart(restart)
[17:29:40.683]                             muffled <- TRUE
[17:29:40.683]                             break
[17:29:40.683]                           }
[17:29:40.683]                         }
[17:29:40.683]                       }
[17:29:40.683]                       invisible(muffled)
[17:29:40.683]                     }
[17:29:40.683]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.683]                   }
[17:29:40.683]                 }
[17:29:40.683]             }
[17:29:40.683]         }))
[17:29:40.683]     }, error = function(ex) {
[17:29:40.683]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:40.683]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.683]                 ...future.rng), started = ...future.startTime, 
[17:29:40.683]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:40.683]             version = "1.8"), class = "FutureResult")
[17:29:40.683]     }, finally = {
[17:29:40.683]         if (!identical(...future.workdir, getwd())) 
[17:29:40.683]             setwd(...future.workdir)
[17:29:40.683]         {
[17:29:40.683]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:40.683]                 ...future.oldOptions$nwarnings <- NULL
[17:29:40.683]             }
[17:29:40.683]             base::options(...future.oldOptions)
[17:29:40.683]             if (.Platform$OS.type == "windows") {
[17:29:40.683]                 old_names <- names(...future.oldEnvVars)
[17:29:40.683]                 envs <- base::Sys.getenv()
[17:29:40.683]                 names <- names(envs)
[17:29:40.683]                 common <- intersect(names, old_names)
[17:29:40.683]                 added <- setdiff(names, old_names)
[17:29:40.683]                 removed <- setdiff(old_names, names)
[17:29:40.683]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:40.683]                   envs[common]]
[17:29:40.683]                 NAMES <- toupper(changed)
[17:29:40.683]                 args <- list()
[17:29:40.683]                 for (kk in seq_along(NAMES)) {
[17:29:40.683]                   name <- changed[[kk]]
[17:29:40.683]                   NAME <- NAMES[[kk]]
[17:29:40.683]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.683]                     next
[17:29:40.683]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.683]                 }
[17:29:40.683]                 NAMES <- toupper(added)
[17:29:40.683]                 for (kk in seq_along(NAMES)) {
[17:29:40.683]                   name <- added[[kk]]
[17:29:40.683]                   NAME <- NAMES[[kk]]
[17:29:40.683]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.683]                     next
[17:29:40.683]                   args[[name]] <- ""
[17:29:40.683]                 }
[17:29:40.683]                 NAMES <- toupper(removed)
[17:29:40.683]                 for (kk in seq_along(NAMES)) {
[17:29:40.683]                   name <- removed[[kk]]
[17:29:40.683]                   NAME <- NAMES[[kk]]
[17:29:40.683]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.683]                     next
[17:29:40.683]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.683]                 }
[17:29:40.683]                 if (length(args) > 0) 
[17:29:40.683]                   base::do.call(base::Sys.setenv, args = args)
[17:29:40.683]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:40.683]             }
[17:29:40.683]             else {
[17:29:40.683]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:40.683]             }
[17:29:40.683]             {
[17:29:40.683]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:40.683]                   0L) {
[17:29:40.683]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:40.683]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:40.683]                   base::options(opts)
[17:29:40.683]                 }
[17:29:40.683]                 {
[17:29:40.683]                   {
[17:29:40.683]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:40.683]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:40.683]                     -1344458670L), envir = base::globalenv(), 
[17:29:40.683]                       inherits = FALSE)
[17:29:40.683]                     NULL
[17:29:40.683]                   }
[17:29:40.683]                   options(future.plan = NULL)
[17:29:40.683]                   if (is.na(NA_character_)) 
[17:29:40.683]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.683]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:40.683]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:40.683]                     .init = FALSE)
[17:29:40.683]                 }
[17:29:40.683]             }
[17:29:40.683]         }
[17:29:40.683]     })
[17:29:40.683]     if (TRUE) {
[17:29:40.683]         base::sink(type = "output", split = FALSE)
[17:29:40.683]         if (TRUE) {
[17:29:40.683]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:40.683]         }
[17:29:40.683]         else {
[17:29:40.683]             ...future.result["stdout"] <- base::list(NULL)
[17:29:40.683]         }
[17:29:40.683]         base::close(...future.stdout)
[17:29:40.683]         ...future.stdout <- NULL
[17:29:40.683]     }
[17:29:40.683]     ...future.result$conditions <- ...future.conditions
[17:29:40.683]     ...future.result$finished <- base::Sys.time()
[17:29:40.683]     ...future.result
[17:29:40.683] }
[17:29:40.690] assign_globals() ...
[17:29:40.690] List of 1
[17:29:40.690]  $ x: int [1:4] 0 1 2 3
[17:29:40.690]  - attr(*, "where")=List of 1
[17:29:40.690]   ..$ x:<environment: R_EmptyEnv> 
[17:29:40.690]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:40.690]  - attr(*, "resolved")= logi FALSE
[17:29:40.690]  - attr(*, "total_size")= int 133
[17:29:40.690]  - attr(*, "already-done")= logi TRUE
[17:29:40.695] - copied 'x' to environment
[17:29:40.696] assign_globals() ... done
[17:29:40.696] plan(): Setting new future strategy stack:
[17:29:40.697] List of future strategies:
[17:29:40.697] 1. sequential:
[17:29:40.697]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.697]    - tweaked: FALSE
[17:29:40.697]    - call: NULL
[17:29:40.698] plan(): nbrOfWorkers() = 1
[17:29:40.700] plan(): Setting new future strategy stack:
[17:29:40.700] List of future strategies:
[17:29:40.700] 1. sequential:
[17:29:40.700]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.700]    - tweaked: FALSE
[17:29:40.700]    - call: plan(strategy)
[17:29:40.701] plan(): nbrOfWorkers() = 1
[17:29:40.701] SequentialFuture started (and completed)
[17:29:40.702] - Launch lazy future ... done
[17:29:40.702] run() for 'SequentialFuture' ... done
[17:29:40.703] getGlobalsAndPackages() ...
[17:29:40.703] Searching for globals...
[17:29:40.705] - globals found: [3] '{', 'sample', 'x'
[17:29:40.705] Searching for globals ... DONE
[17:29:40.706] Resolving globals: FALSE
[17:29:40.707] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:40.707] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:40.708] - globals: [1] 'x'
[17:29:40.708] 
[17:29:40.708] getGlobalsAndPackages() ... DONE
[17:29:40.709] run() for 'Future' ...
[17:29:40.709] - state: 'created'
[17:29:40.713] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:40.713] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.714] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:40.714]   - Field: 'label'
[17:29:40.714]   - Field: 'local'
[17:29:40.715]   - Field: 'owner'
[17:29:40.715]   - Field: 'envir'
[17:29:40.715]   - Field: 'packages'
[17:29:40.716]   - Field: 'gc'
[17:29:40.716]   - Field: 'conditions'
[17:29:40.717]   - Field: 'expr'
[17:29:40.717]   - Field: 'uuid'
[17:29:40.717]   - Field: 'seed'
[17:29:40.717]   - Field: 'version'
[17:29:40.718]   - Field: 'result'
[17:29:40.718]   - Field: 'asynchronous'
[17:29:40.719]   - Field: 'calls'
[17:29:40.719]   - Field: 'globals'
[17:29:40.719]   - Field: 'stdout'
[17:29:40.720]   - Field: 'earlySignal'
[17:29:40.720]   - Field: 'lazy'
[17:29:40.720]   - Field: 'state'
[17:29:40.721] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:40.721] - Launch lazy future ...
[17:29:40.722] Packages needed by the future expression (n = 0): <none>
[17:29:40.722] Packages needed by future strategies (n = 0): <none>
[17:29:40.723] {
[17:29:40.723]     {
[17:29:40.723]         {
[17:29:40.723]             ...future.startTime <- base::Sys.time()
[17:29:40.723]             {
[17:29:40.723]                 {
[17:29:40.723]                   {
[17:29:40.723]                     {
[17:29:40.723]                       base::local({
[17:29:40.723]                         has_future <- base::requireNamespace("future", 
[17:29:40.723]                           quietly = TRUE)
[17:29:40.723]                         if (has_future) {
[17:29:40.723]                           ns <- base::getNamespace("future")
[17:29:40.723]                           version <- ns[[".package"]][["version"]]
[17:29:40.723]                           if (is.null(version)) 
[17:29:40.723]                             version <- utils::packageVersion("future")
[17:29:40.723]                         }
[17:29:40.723]                         else {
[17:29:40.723]                           version <- NULL
[17:29:40.723]                         }
[17:29:40.723]                         if (!has_future || version < "1.8.0") {
[17:29:40.723]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:40.723]                             "", base::R.version$version.string), 
[17:29:40.723]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:40.723]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:40.723]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:40.723]                               "release", "version")], collapse = " "), 
[17:29:40.723]                             hostname = base::Sys.info()[["nodename"]])
[17:29:40.723]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:40.723]                             info)
[17:29:40.723]                           info <- base::paste(info, collapse = "; ")
[17:29:40.723]                           if (!has_future) {
[17:29:40.723]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:40.723]                               info)
[17:29:40.723]                           }
[17:29:40.723]                           else {
[17:29:40.723]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:40.723]                               info, version)
[17:29:40.723]                           }
[17:29:40.723]                           base::stop(msg)
[17:29:40.723]                         }
[17:29:40.723]                       })
[17:29:40.723]                     }
[17:29:40.723]                     ...future.strategy.old <- future::plan("list")
[17:29:40.723]                     options(future.plan = NULL)
[17:29:40.723]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.723]                     future::plan("default", .cleanup = FALSE, 
[17:29:40.723]                       .init = FALSE)
[17:29:40.723]                   }
[17:29:40.723]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[17:29:40.723]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[17:29:40.723]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[17:29:40.723]                 }
[17:29:40.723]                 ...future.workdir <- getwd()
[17:29:40.723]             }
[17:29:40.723]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:40.723]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:40.723]         }
[17:29:40.723]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:40.723]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:40.723]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:40.723]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:40.723]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:40.723]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:40.723]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:40.723]             base::names(...future.oldOptions))
[17:29:40.723]     }
[17:29:40.723]     if (FALSE) {
[17:29:40.723]     }
[17:29:40.723]     else {
[17:29:40.723]         if (TRUE) {
[17:29:40.723]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:40.723]                 open = "w")
[17:29:40.723]         }
[17:29:40.723]         else {
[17:29:40.723]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:40.723]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:40.723]         }
[17:29:40.723]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:40.723]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:40.723]             base::sink(type = "output", split = FALSE)
[17:29:40.723]             base::close(...future.stdout)
[17:29:40.723]         }, add = TRUE)
[17:29:40.723]     }
[17:29:40.723]     ...future.frame <- base::sys.nframe()
[17:29:40.723]     ...future.conditions <- base::list()
[17:29:40.723]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:40.723]     if (FALSE) {
[17:29:40.723]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:40.723]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:40.723]     }
[17:29:40.723]     ...future.result <- base::tryCatch({
[17:29:40.723]         base::withCallingHandlers({
[17:29:40.723]             ...future.value <- base::withVisible(base::local({
[17:29:40.723]                 sample(x, size = 1L)
[17:29:40.723]             }))
[17:29:40.723]             future::FutureResult(value = ...future.value$value, 
[17:29:40.723]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.723]                   ...future.rng), globalenv = if (FALSE) 
[17:29:40.723]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:40.723]                     ...future.globalenv.names))
[17:29:40.723]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:40.723]         }, condition = base::local({
[17:29:40.723]             c <- base::c
[17:29:40.723]             inherits <- base::inherits
[17:29:40.723]             invokeRestart <- base::invokeRestart
[17:29:40.723]             length <- base::length
[17:29:40.723]             list <- base::list
[17:29:40.723]             seq.int <- base::seq.int
[17:29:40.723]             signalCondition <- base::signalCondition
[17:29:40.723]             sys.calls <- base::sys.calls
[17:29:40.723]             `[[` <- base::`[[`
[17:29:40.723]             `+` <- base::`+`
[17:29:40.723]             `<<-` <- base::`<<-`
[17:29:40.723]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:40.723]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:40.723]                   3L)]
[17:29:40.723]             }
[17:29:40.723]             function(cond) {
[17:29:40.723]                 is_error <- inherits(cond, "error")
[17:29:40.723]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:40.723]                   NULL)
[17:29:40.723]                 if (is_error) {
[17:29:40.723]                   sessionInformation <- function() {
[17:29:40.723]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:40.723]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:40.723]                       search = base::search(), system = base::Sys.info())
[17:29:40.723]                   }
[17:29:40.723]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.723]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:40.723]                     cond$call), session = sessionInformation(), 
[17:29:40.723]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:40.723]                   signalCondition(cond)
[17:29:40.723]                 }
[17:29:40.723]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:40.723]                 "immediateCondition"))) {
[17:29:40.723]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:40.723]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.723]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:40.723]                   if (TRUE && !signal) {
[17:29:40.723]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.723]                     {
[17:29:40.723]                       inherits <- base::inherits
[17:29:40.723]                       invokeRestart <- base::invokeRestart
[17:29:40.723]                       is.null <- base::is.null
[17:29:40.723]                       muffled <- FALSE
[17:29:40.723]                       if (inherits(cond, "message")) {
[17:29:40.723]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.723]                         if (muffled) 
[17:29:40.723]                           invokeRestart("muffleMessage")
[17:29:40.723]                       }
[17:29:40.723]                       else if (inherits(cond, "warning")) {
[17:29:40.723]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.723]                         if (muffled) 
[17:29:40.723]                           invokeRestart("muffleWarning")
[17:29:40.723]                       }
[17:29:40.723]                       else if (inherits(cond, "condition")) {
[17:29:40.723]                         if (!is.null(pattern)) {
[17:29:40.723]                           computeRestarts <- base::computeRestarts
[17:29:40.723]                           grepl <- base::grepl
[17:29:40.723]                           restarts <- computeRestarts(cond)
[17:29:40.723]                           for (restart in restarts) {
[17:29:40.723]                             name <- restart$name
[17:29:40.723]                             if (is.null(name)) 
[17:29:40.723]                               next
[17:29:40.723]                             if (!grepl(pattern, name)) 
[17:29:40.723]                               next
[17:29:40.723]                             invokeRestart(restart)
[17:29:40.723]                             muffled <- TRUE
[17:29:40.723]                             break
[17:29:40.723]                           }
[17:29:40.723]                         }
[17:29:40.723]                       }
[17:29:40.723]                       invisible(muffled)
[17:29:40.723]                     }
[17:29:40.723]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.723]                   }
[17:29:40.723]                 }
[17:29:40.723]                 else {
[17:29:40.723]                   if (TRUE) {
[17:29:40.723]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.723]                     {
[17:29:40.723]                       inherits <- base::inherits
[17:29:40.723]                       invokeRestart <- base::invokeRestart
[17:29:40.723]                       is.null <- base::is.null
[17:29:40.723]                       muffled <- FALSE
[17:29:40.723]                       if (inherits(cond, "message")) {
[17:29:40.723]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.723]                         if (muffled) 
[17:29:40.723]                           invokeRestart("muffleMessage")
[17:29:40.723]                       }
[17:29:40.723]                       else if (inherits(cond, "warning")) {
[17:29:40.723]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.723]                         if (muffled) 
[17:29:40.723]                           invokeRestart("muffleWarning")
[17:29:40.723]                       }
[17:29:40.723]                       else if (inherits(cond, "condition")) {
[17:29:40.723]                         if (!is.null(pattern)) {
[17:29:40.723]                           computeRestarts <- base::computeRestarts
[17:29:40.723]                           grepl <- base::grepl
[17:29:40.723]                           restarts <- computeRestarts(cond)
[17:29:40.723]                           for (restart in restarts) {
[17:29:40.723]                             name <- restart$name
[17:29:40.723]                             if (is.null(name)) 
[17:29:40.723]                               next
[17:29:40.723]                             if (!grepl(pattern, name)) 
[17:29:40.723]                               next
[17:29:40.723]                             invokeRestart(restart)
[17:29:40.723]                             muffled <- TRUE
[17:29:40.723]                             break
[17:29:40.723]                           }
[17:29:40.723]                         }
[17:29:40.723]                       }
[17:29:40.723]                       invisible(muffled)
[17:29:40.723]                     }
[17:29:40.723]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.723]                   }
[17:29:40.723]                 }
[17:29:40.723]             }
[17:29:40.723]         }))
[17:29:40.723]     }, error = function(ex) {
[17:29:40.723]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:40.723]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.723]                 ...future.rng), started = ...future.startTime, 
[17:29:40.723]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:40.723]             version = "1.8"), class = "FutureResult")
[17:29:40.723]     }, finally = {
[17:29:40.723]         if (!identical(...future.workdir, getwd())) 
[17:29:40.723]             setwd(...future.workdir)
[17:29:40.723]         {
[17:29:40.723]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:40.723]                 ...future.oldOptions$nwarnings <- NULL
[17:29:40.723]             }
[17:29:40.723]             base::options(...future.oldOptions)
[17:29:40.723]             if (.Platform$OS.type == "windows") {
[17:29:40.723]                 old_names <- names(...future.oldEnvVars)
[17:29:40.723]                 envs <- base::Sys.getenv()
[17:29:40.723]                 names <- names(envs)
[17:29:40.723]                 common <- intersect(names, old_names)
[17:29:40.723]                 added <- setdiff(names, old_names)
[17:29:40.723]                 removed <- setdiff(old_names, names)
[17:29:40.723]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:40.723]                   envs[common]]
[17:29:40.723]                 NAMES <- toupper(changed)
[17:29:40.723]                 args <- list()
[17:29:40.723]                 for (kk in seq_along(NAMES)) {
[17:29:40.723]                   name <- changed[[kk]]
[17:29:40.723]                   NAME <- NAMES[[kk]]
[17:29:40.723]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.723]                     next
[17:29:40.723]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.723]                 }
[17:29:40.723]                 NAMES <- toupper(added)
[17:29:40.723]                 for (kk in seq_along(NAMES)) {
[17:29:40.723]                   name <- added[[kk]]
[17:29:40.723]                   NAME <- NAMES[[kk]]
[17:29:40.723]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.723]                     next
[17:29:40.723]                   args[[name]] <- ""
[17:29:40.723]                 }
[17:29:40.723]                 NAMES <- toupper(removed)
[17:29:40.723]                 for (kk in seq_along(NAMES)) {
[17:29:40.723]                   name <- removed[[kk]]
[17:29:40.723]                   NAME <- NAMES[[kk]]
[17:29:40.723]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.723]                     next
[17:29:40.723]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.723]                 }
[17:29:40.723]                 if (length(args) > 0) 
[17:29:40.723]                   base::do.call(base::Sys.setenv, args = args)
[17:29:40.723]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:40.723]             }
[17:29:40.723]             else {
[17:29:40.723]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:40.723]             }
[17:29:40.723]             {
[17:29:40.723]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:40.723]                   0L) {
[17:29:40.723]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:40.723]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:40.723]                   base::options(opts)
[17:29:40.723]                 }
[17:29:40.723]                 {
[17:29:40.723]                   {
[17:29:40.723]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:40.723]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:40.723]                     -1344458670L), envir = base::globalenv(), 
[17:29:40.723]                       inherits = FALSE)
[17:29:40.723]                     NULL
[17:29:40.723]                   }
[17:29:40.723]                   options(future.plan = NULL)
[17:29:40.723]                   if (is.na(NA_character_)) 
[17:29:40.723]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.723]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:40.723]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:40.723]                     .init = FALSE)
[17:29:40.723]                 }
[17:29:40.723]             }
[17:29:40.723]         }
[17:29:40.723]     })
[17:29:40.723]     if (TRUE) {
[17:29:40.723]         base::sink(type = "output", split = FALSE)
[17:29:40.723]         if (TRUE) {
[17:29:40.723]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:40.723]         }
[17:29:40.723]         else {
[17:29:40.723]             ...future.result["stdout"] <- base::list(NULL)
[17:29:40.723]         }
[17:29:40.723]         base::close(...future.stdout)
[17:29:40.723]         ...future.stdout <- NULL
[17:29:40.723]     }
[17:29:40.723]     ...future.result$conditions <- ...future.conditions
[17:29:40.723]     ...future.result$finished <- base::Sys.time()
[17:29:40.723]     ...future.result
[17:29:40.723] }
[17:29:40.730] assign_globals() ...
[17:29:40.730] List of 1
[17:29:40.730]  $ x: int [1:4] 0 1 2 3
[17:29:40.730]  - attr(*, "where")=List of 1
[17:29:40.730]   ..$ x:<environment: R_EmptyEnv> 
[17:29:40.730]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:40.730]  - attr(*, "resolved")= logi FALSE
[17:29:40.730]  - attr(*, "total_size")= int 133
[17:29:40.730]  - attr(*, "already-done")= logi TRUE
[17:29:40.736] - copied 'x' to environment
[17:29:40.736] assign_globals() ... done
[17:29:40.737] plan(): Setting new future strategy stack:
[17:29:40.737] List of future strategies:
[17:29:40.737] 1. sequential:
[17:29:40.737]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.737]    - tweaked: FALSE
[17:29:40.737]    - call: NULL
[17:29:40.738] plan(): nbrOfWorkers() = 1
[17:29:40.740] plan(): Setting new future strategy stack:
[17:29:40.740] List of future strategies:
[17:29:40.740] 1. sequential:
[17:29:40.740]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.740]    - tweaked: FALSE
[17:29:40.740]    - call: plan(strategy)
[17:29:40.741] plan(): nbrOfWorkers() = 1
[17:29:40.741] SequentialFuture started (and completed)
[17:29:40.741] - Launch lazy future ... done
[17:29:40.741] run() for 'SequentialFuture' ... done
[17:29:40.742] getGlobalsAndPackages() ...
[17:29:40.742] Searching for globals...
[17:29:40.743] - globals found: [3] '{', 'sample', 'x'
[17:29:40.743] Searching for globals ... DONE
[17:29:40.744] Resolving globals: FALSE
[17:29:40.744] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:40.745] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:40.745] - globals: [1] 'x'
[17:29:40.745] 
[17:29:40.746] getGlobalsAndPackages() ... DONE
[17:29:40.746] run() for 'Future' ...
[17:29:40.746] - state: 'created'
[17:29:40.746] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:40.747] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.747] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:40.747]   - Field: 'label'
[17:29:40.747]   - Field: 'local'
[17:29:40.748]   - Field: 'owner'
[17:29:40.748]   - Field: 'envir'
[17:29:40.748]   - Field: 'packages'
[17:29:40.748]   - Field: 'gc'
[17:29:40.748]   - Field: 'conditions'
[17:29:40.748]   - Field: 'expr'
[17:29:40.749]   - Field: 'uuid'
[17:29:40.749]   - Field: 'seed'
[17:29:40.749]   - Field: 'version'
[17:29:40.749]   - Field: 'result'
[17:29:40.749]   - Field: 'asynchronous'
[17:29:40.750]   - Field: 'calls'
[17:29:40.750]   - Field: 'globals'
[17:29:40.750]   - Field: 'stdout'
[17:29:40.750]   - Field: 'earlySignal'
[17:29:40.750]   - Field: 'lazy'
[17:29:40.750]   - Field: 'state'
[17:29:40.751] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:40.751] - Launch lazy future ...
[17:29:40.751] Packages needed by the future expression (n = 0): <none>
[17:29:40.751] Packages needed by future strategies (n = 0): <none>
[17:29:40.752] {
[17:29:40.752]     {
[17:29:40.752]         {
[17:29:40.752]             ...future.startTime <- base::Sys.time()
[17:29:40.752]             {
[17:29:40.752]                 {
[17:29:40.752]                   {
[17:29:40.752]                     {
[17:29:40.752]                       base::local({
[17:29:40.752]                         has_future <- base::requireNamespace("future", 
[17:29:40.752]                           quietly = TRUE)
[17:29:40.752]                         if (has_future) {
[17:29:40.752]                           ns <- base::getNamespace("future")
[17:29:40.752]                           version <- ns[[".package"]][["version"]]
[17:29:40.752]                           if (is.null(version)) 
[17:29:40.752]                             version <- utils::packageVersion("future")
[17:29:40.752]                         }
[17:29:40.752]                         else {
[17:29:40.752]                           version <- NULL
[17:29:40.752]                         }
[17:29:40.752]                         if (!has_future || version < "1.8.0") {
[17:29:40.752]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:40.752]                             "", base::R.version$version.string), 
[17:29:40.752]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:40.752]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:40.752]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:40.752]                               "release", "version")], collapse = " "), 
[17:29:40.752]                             hostname = base::Sys.info()[["nodename"]])
[17:29:40.752]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:40.752]                             info)
[17:29:40.752]                           info <- base::paste(info, collapse = "; ")
[17:29:40.752]                           if (!has_future) {
[17:29:40.752]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:40.752]                               info)
[17:29:40.752]                           }
[17:29:40.752]                           else {
[17:29:40.752]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:40.752]                               info, version)
[17:29:40.752]                           }
[17:29:40.752]                           base::stop(msg)
[17:29:40.752]                         }
[17:29:40.752]                       })
[17:29:40.752]                     }
[17:29:40.752]                     ...future.strategy.old <- future::plan("list")
[17:29:40.752]                     options(future.plan = NULL)
[17:29:40.752]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.752]                     future::plan("default", .cleanup = FALSE, 
[17:29:40.752]                       .init = FALSE)
[17:29:40.752]                   }
[17:29:40.752]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[17:29:40.752]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[17:29:40.752]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[17:29:40.752]                 }
[17:29:40.752]                 ...future.workdir <- getwd()
[17:29:40.752]             }
[17:29:40.752]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:40.752]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:40.752]         }
[17:29:40.752]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:40.752]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:40.752]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:40.752]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:40.752]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:29:40.752]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:40.752]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:40.752]             base::names(...future.oldOptions))
[17:29:40.752]     }
[17:29:40.752]     if (FALSE) {
[17:29:40.752]     }
[17:29:40.752]     else {
[17:29:40.752]         if (TRUE) {
[17:29:40.752]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:40.752]                 open = "w")
[17:29:40.752]         }
[17:29:40.752]         else {
[17:29:40.752]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:40.752]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:40.752]         }
[17:29:40.752]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:40.752]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:40.752]             base::sink(type = "output", split = FALSE)
[17:29:40.752]             base::close(...future.stdout)
[17:29:40.752]         }, add = TRUE)
[17:29:40.752]     }
[17:29:40.752]     ...future.frame <- base::sys.nframe()
[17:29:40.752]     ...future.conditions <- base::list()
[17:29:40.752]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:40.752]     if (FALSE) {
[17:29:40.752]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:40.752]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:40.752]     }
[17:29:40.752]     ...future.result <- base::tryCatch({
[17:29:40.752]         base::withCallingHandlers({
[17:29:40.752]             ...future.value <- base::withVisible(base::local({
[17:29:40.752]                 sample(x, size = 1L)
[17:29:40.752]             }))
[17:29:40.752]             future::FutureResult(value = ...future.value$value, 
[17:29:40.752]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.752]                   ...future.rng), globalenv = if (FALSE) 
[17:29:40.752]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:40.752]                     ...future.globalenv.names))
[17:29:40.752]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:40.752]         }, condition = base::local({
[17:29:40.752]             c <- base::c
[17:29:40.752]             inherits <- base::inherits
[17:29:40.752]             invokeRestart <- base::invokeRestart
[17:29:40.752]             length <- base::length
[17:29:40.752]             list <- base::list
[17:29:40.752]             seq.int <- base::seq.int
[17:29:40.752]             signalCondition <- base::signalCondition
[17:29:40.752]             sys.calls <- base::sys.calls
[17:29:40.752]             `[[` <- base::`[[`
[17:29:40.752]             `+` <- base::`+`
[17:29:40.752]             `<<-` <- base::`<<-`
[17:29:40.752]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:40.752]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:40.752]                   3L)]
[17:29:40.752]             }
[17:29:40.752]             function(cond) {
[17:29:40.752]                 is_error <- inherits(cond, "error")
[17:29:40.752]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:40.752]                   NULL)
[17:29:40.752]                 if (is_error) {
[17:29:40.752]                   sessionInformation <- function() {
[17:29:40.752]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:40.752]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:40.752]                       search = base::search(), system = base::Sys.info())
[17:29:40.752]                   }
[17:29:40.752]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.752]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:40.752]                     cond$call), session = sessionInformation(), 
[17:29:40.752]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:40.752]                   signalCondition(cond)
[17:29:40.752]                 }
[17:29:40.752]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:40.752]                 "immediateCondition"))) {
[17:29:40.752]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:40.752]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.752]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:40.752]                   if (TRUE && !signal) {
[17:29:40.752]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.752]                     {
[17:29:40.752]                       inherits <- base::inherits
[17:29:40.752]                       invokeRestart <- base::invokeRestart
[17:29:40.752]                       is.null <- base::is.null
[17:29:40.752]                       muffled <- FALSE
[17:29:40.752]                       if (inherits(cond, "message")) {
[17:29:40.752]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.752]                         if (muffled) 
[17:29:40.752]                           invokeRestart("muffleMessage")
[17:29:40.752]                       }
[17:29:40.752]                       else if (inherits(cond, "warning")) {
[17:29:40.752]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.752]                         if (muffled) 
[17:29:40.752]                           invokeRestart("muffleWarning")
[17:29:40.752]                       }
[17:29:40.752]                       else if (inherits(cond, "condition")) {
[17:29:40.752]                         if (!is.null(pattern)) {
[17:29:40.752]                           computeRestarts <- base::computeRestarts
[17:29:40.752]                           grepl <- base::grepl
[17:29:40.752]                           restarts <- computeRestarts(cond)
[17:29:40.752]                           for (restart in restarts) {
[17:29:40.752]                             name <- restart$name
[17:29:40.752]                             if (is.null(name)) 
[17:29:40.752]                               next
[17:29:40.752]                             if (!grepl(pattern, name)) 
[17:29:40.752]                               next
[17:29:40.752]                             invokeRestart(restart)
[17:29:40.752]                             muffled <- TRUE
[17:29:40.752]                             break
[17:29:40.752]                           }
[17:29:40.752]                         }
[17:29:40.752]                       }
[17:29:40.752]                       invisible(muffled)
[17:29:40.752]                     }
[17:29:40.752]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.752]                   }
[17:29:40.752]                 }
[17:29:40.752]                 else {
[17:29:40.752]                   if (TRUE) {
[17:29:40.752]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.752]                     {
[17:29:40.752]                       inherits <- base::inherits
[17:29:40.752]                       invokeRestart <- base::invokeRestart
[17:29:40.752]                       is.null <- base::is.null
[17:29:40.752]                       muffled <- FALSE
[17:29:40.752]                       if (inherits(cond, "message")) {
[17:29:40.752]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.752]                         if (muffled) 
[17:29:40.752]                           invokeRestart("muffleMessage")
[17:29:40.752]                       }
[17:29:40.752]                       else if (inherits(cond, "warning")) {
[17:29:40.752]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.752]                         if (muffled) 
[17:29:40.752]                           invokeRestart("muffleWarning")
[17:29:40.752]                       }
[17:29:40.752]                       else if (inherits(cond, "condition")) {
[17:29:40.752]                         if (!is.null(pattern)) {
[17:29:40.752]                           computeRestarts <- base::computeRestarts
[17:29:40.752]                           grepl <- base::grepl
[17:29:40.752]                           restarts <- computeRestarts(cond)
[17:29:40.752]                           for (restart in restarts) {
[17:29:40.752]                             name <- restart$name
[17:29:40.752]                             if (is.null(name)) 
[17:29:40.752]                               next
[17:29:40.752]                             if (!grepl(pattern, name)) 
[17:29:40.752]                               next
[17:29:40.752]                             invokeRestart(restart)
[17:29:40.752]                             muffled <- TRUE
[17:29:40.752]                             break
[17:29:40.752]                           }
[17:29:40.752]                         }
[17:29:40.752]                       }
[17:29:40.752]                       invisible(muffled)
[17:29:40.752]                     }
[17:29:40.752]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.752]                   }
[17:29:40.752]                 }
[17:29:40.752]             }
[17:29:40.752]         }))
[17:29:40.752]     }, error = function(ex) {
[17:29:40.752]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:40.752]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.752]                 ...future.rng), started = ...future.startTime, 
[17:29:40.752]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:40.752]             version = "1.8"), class = "FutureResult")
[17:29:40.752]     }, finally = {
[17:29:40.752]         if (!identical(...future.workdir, getwd())) 
[17:29:40.752]             setwd(...future.workdir)
[17:29:40.752]         {
[17:29:40.752]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:40.752]                 ...future.oldOptions$nwarnings <- NULL
[17:29:40.752]             }
[17:29:40.752]             base::options(...future.oldOptions)
[17:29:40.752]             if (.Platform$OS.type == "windows") {
[17:29:40.752]                 old_names <- names(...future.oldEnvVars)
[17:29:40.752]                 envs <- base::Sys.getenv()
[17:29:40.752]                 names <- names(envs)
[17:29:40.752]                 common <- intersect(names, old_names)
[17:29:40.752]                 added <- setdiff(names, old_names)
[17:29:40.752]                 removed <- setdiff(old_names, names)
[17:29:40.752]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:40.752]                   envs[common]]
[17:29:40.752]                 NAMES <- toupper(changed)
[17:29:40.752]                 args <- list()
[17:29:40.752]                 for (kk in seq_along(NAMES)) {
[17:29:40.752]                   name <- changed[[kk]]
[17:29:40.752]                   NAME <- NAMES[[kk]]
[17:29:40.752]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.752]                     next
[17:29:40.752]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.752]                 }
[17:29:40.752]                 NAMES <- toupper(added)
[17:29:40.752]                 for (kk in seq_along(NAMES)) {
[17:29:40.752]                   name <- added[[kk]]
[17:29:40.752]                   NAME <- NAMES[[kk]]
[17:29:40.752]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.752]                     next
[17:29:40.752]                   args[[name]] <- ""
[17:29:40.752]                 }
[17:29:40.752]                 NAMES <- toupper(removed)
[17:29:40.752]                 for (kk in seq_along(NAMES)) {
[17:29:40.752]                   name <- removed[[kk]]
[17:29:40.752]                   NAME <- NAMES[[kk]]
[17:29:40.752]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.752]                     next
[17:29:40.752]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.752]                 }
[17:29:40.752]                 if (length(args) > 0) 
[17:29:40.752]                   base::do.call(base::Sys.setenv, args = args)
[17:29:40.752]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:40.752]             }
[17:29:40.752]             else {
[17:29:40.752]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:40.752]             }
[17:29:40.752]             {
[17:29:40.752]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:40.752]                   0L) {
[17:29:40.752]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:40.752]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:40.752]                   base::options(opts)
[17:29:40.752]                 }
[17:29:40.752]                 {
[17:29:40.752]                   {
[17:29:40.752]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:40.752]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:40.752]                     -1344458670L), envir = base::globalenv(), 
[17:29:40.752]                       inherits = FALSE)
[17:29:40.752]                     NULL
[17:29:40.752]                   }
[17:29:40.752]                   options(future.plan = NULL)
[17:29:40.752]                   if (is.na(NA_character_)) 
[17:29:40.752]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.752]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:40.752]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:40.752]                     .init = FALSE)
[17:29:40.752]                 }
[17:29:40.752]             }
[17:29:40.752]         }
[17:29:40.752]     })
[17:29:40.752]     if (TRUE) {
[17:29:40.752]         base::sink(type = "output", split = FALSE)
[17:29:40.752]         if (TRUE) {
[17:29:40.752]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:40.752]         }
[17:29:40.752]         else {
[17:29:40.752]             ...future.result["stdout"] <- base::list(NULL)
[17:29:40.752]         }
[17:29:40.752]         base::close(...future.stdout)
[17:29:40.752]         ...future.stdout <- NULL
[17:29:40.752]     }
[17:29:40.752]     ...future.result$conditions <- ...future.conditions
[17:29:40.752]     ...future.result$finished <- base::Sys.time()
[17:29:40.752]     ...future.result
[17:29:40.752] }
[17:29:40.758] assign_globals() ...
[17:29:40.758] List of 1
[17:29:40.758]  $ x: int [1:4] 0 1 2 3
[17:29:40.758]  - attr(*, "where")=List of 1
[17:29:40.758]   ..$ x:<environment: R_EmptyEnv> 
[17:29:40.758]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:40.758]  - attr(*, "resolved")= logi FALSE
[17:29:40.758]  - attr(*, "total_size")= int 133
[17:29:40.758]  - attr(*, "already-done")= logi TRUE
[17:29:40.765] - copied 'x' to environment
[17:29:40.766] assign_globals() ... done
[17:29:40.766] plan(): Setting new future strategy stack:
[17:29:40.767] List of future strategies:
[17:29:40.767] 1. sequential:
[17:29:40.767]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.767]    - tweaked: FALSE
[17:29:40.767]    - call: NULL
[17:29:40.768] plan(): nbrOfWorkers() = 1
[17:29:40.770] plan(): Setting new future strategy stack:
[17:29:40.770] List of future strategies:
[17:29:40.770] 1. sequential:
[17:29:40.770]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.770]    - tweaked: FALSE
[17:29:40.770]    - call: plan(strategy)
[17:29:40.771] plan(): nbrOfWorkers() = 1
[17:29:40.771] SequentialFuture started (and completed)
[17:29:40.771] - Launch lazy future ... done
[17:29:40.772] run() for 'SequentialFuture' ... done
[17:29:40.772] resolve() on list ...
[17:29:40.772]  recursive: 0
[17:29:40.773]  length: 4
[17:29:40.773] 
[17:29:40.773] resolved() for 'SequentialFuture' ...
[17:29:40.773] - state: 'finished'
[17:29:40.774] - run: TRUE
[17:29:40.774] - result: 'FutureResult'
[17:29:40.774] resolved() for 'SequentialFuture' ... done
[17:29:40.775] Future #1
[17:29:40.775] signalConditionsASAP(SequentialFuture, pos=1) ...
[17:29:40.775] - nx: 4
[17:29:40.775] - relay: TRUE
[17:29:40.776] - stdout: TRUE
[17:29:40.776] - signal: TRUE
[17:29:40.776] - resignal: FALSE
[17:29:40.776] - force: TRUE
[17:29:40.777] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:40.777] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:40.777]  - until=1
[17:29:40.777]  - relaying element #1
[17:29:40.778] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:40.778] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:40.778] signalConditionsASAP(SequentialFuture, pos=1) ... done
[17:29:40.779]  length: 3 (resolved future 1)
[17:29:40.779] resolved() for 'SequentialFuture' ...
[17:29:40.779] - state: 'finished'
[17:29:40.780] - run: TRUE
[17:29:40.780] - result: 'FutureResult'
[17:29:40.780] resolved() for 'SequentialFuture' ... done
[17:29:40.781] Future #2
[17:29:40.781] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:29:40.781] - nx: 4
[17:29:40.781] - relay: TRUE
[17:29:40.782] - stdout: TRUE
[17:29:40.782] - signal: TRUE
[17:29:40.782] - resignal: FALSE
[17:29:40.782] - force: TRUE
[17:29:40.783] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:40.783] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:40.783]  - until=2
[17:29:40.783]  - relaying element #2
[17:29:40.784] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:40.784] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:40.784] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:29:40.785]  length: 2 (resolved future 2)
[17:29:40.785] resolved() for 'SequentialFuture' ...
[17:29:40.785] - state: 'finished'
[17:29:40.786] - run: TRUE
[17:29:40.786] - result: 'FutureResult'
[17:29:40.786] resolved() for 'SequentialFuture' ... done
[17:29:40.786] Future #3
[17:29:40.787] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:29:40.787] - nx: 4
[17:29:40.787] - relay: TRUE
[17:29:40.787] - stdout: TRUE
[17:29:40.788] - signal: TRUE
[17:29:40.788] - resignal: FALSE
[17:29:40.788] - force: TRUE
[17:29:40.788] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:40.789] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:40.789]  - until=3
[17:29:40.789]  - relaying element #3
[17:29:40.790] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:40.790] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:40.790] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:29:40.790]  length: 1 (resolved future 3)
[17:29:40.791] resolved() for 'SequentialFuture' ...
[17:29:40.791] - state: 'finished'
[17:29:40.791] - run: TRUE
[17:29:40.792] - result: 'FutureResult'
[17:29:40.792] resolved() for 'SequentialFuture' ... done
[17:29:40.792] Future #4
[17:29:40.793] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:29:40.793] - nx: 4
[17:29:40.793] - relay: TRUE
[17:29:40.793] - stdout: TRUE
[17:29:40.794] - signal: TRUE
[17:29:40.794] - resignal: FALSE
[17:29:40.794] - force: TRUE
[17:29:40.794] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:40.795] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:40.795]  - until=4
[17:29:40.795]  - relaying element #4
[17:29:40.796] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.796] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.796] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:29:40.796]  length: 0 (resolved future 4)
[17:29:40.797] Relaying remaining futures
[17:29:40.797] signalConditionsASAP(NULL, pos=0) ...
[17:29:40.797] - nx: 4
[17:29:40.797] - relay: TRUE
[17:29:40.798] - stdout: TRUE
[17:29:40.798] - signal: TRUE
[17:29:40.798] - resignal: FALSE
[17:29:40.798] - force: TRUE
[17:29:40.799] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.799] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:29:40.799] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.800] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.800] signalConditionsASAP(NULL, pos=0) ... done
[17:29:40.800] resolve() on list ... DONE
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[17:29:40.801] getGlobalsAndPackages() ...
[17:29:40.802] Searching for globals...
[17:29:40.804] - globals found: [3] '{', 'sample', 'x'
[17:29:40.804] Searching for globals ... DONE
[17:29:40.804] Resolving globals: FALSE
[17:29:40.805] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:40.806] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:40.806] - globals: [1] 'x'
[17:29:40.806] 
[17:29:40.806] getGlobalsAndPackages() ... DONE
[17:29:40.807] run() for 'Future' ...
[17:29:40.807] - state: 'created'
[17:29:40.808] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:40.808] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.811] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:40.812]   - Field: 'label'
[17:29:40.812]   - Field: 'local'
[17:29:40.812]   - Field: 'owner'
[17:29:40.812]   - Field: 'envir'
[17:29:40.813]   - Field: 'packages'
[17:29:40.813]   - Field: 'gc'
[17:29:40.813]   - Field: 'conditions'
[17:29:40.814]   - Field: 'expr'
[17:29:40.814]   - Field: 'uuid'
[17:29:40.814]   - Field: 'seed'
[17:29:40.814]   - Field: 'version'
[17:29:40.815]   - Field: 'result'
[17:29:40.815]   - Field: 'asynchronous'
[17:29:40.815]   - Field: 'calls'
[17:29:40.816]   - Field: 'globals'
[17:29:40.816]   - Field: 'stdout'
[17:29:40.816]   - Field: 'earlySignal'
[17:29:40.816]   - Field: 'lazy'
[17:29:40.817]   - Field: 'state'
[17:29:40.817] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:40.817] - Launch lazy future ...
[17:29:40.818] Packages needed by the future expression (n = 0): <none>
[17:29:40.818] Packages needed by future strategies (n = 0): <none>
[17:29:40.819] {
[17:29:40.819]     {
[17:29:40.819]         {
[17:29:40.819]             ...future.startTime <- base::Sys.time()
[17:29:40.819]             {
[17:29:40.819]                 {
[17:29:40.819]                   {
[17:29:40.819]                     base::local({
[17:29:40.819]                       has_future <- base::requireNamespace("future", 
[17:29:40.819]                         quietly = TRUE)
[17:29:40.819]                       if (has_future) {
[17:29:40.819]                         ns <- base::getNamespace("future")
[17:29:40.819]                         version <- ns[[".package"]][["version"]]
[17:29:40.819]                         if (is.null(version)) 
[17:29:40.819]                           version <- utils::packageVersion("future")
[17:29:40.819]                       }
[17:29:40.819]                       else {
[17:29:40.819]                         version <- NULL
[17:29:40.819]                       }
[17:29:40.819]                       if (!has_future || version < "1.8.0") {
[17:29:40.819]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:40.819]                           "", base::R.version$version.string), 
[17:29:40.819]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:40.819]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:40.819]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:40.819]                             "release", "version")], collapse = " "), 
[17:29:40.819]                           hostname = base::Sys.info()[["nodename"]])
[17:29:40.819]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:40.819]                           info)
[17:29:40.819]                         info <- base::paste(info, collapse = "; ")
[17:29:40.819]                         if (!has_future) {
[17:29:40.819]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:40.819]                             info)
[17:29:40.819]                         }
[17:29:40.819]                         else {
[17:29:40.819]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:40.819]                             info, version)
[17:29:40.819]                         }
[17:29:40.819]                         base::stop(msg)
[17:29:40.819]                       }
[17:29:40.819]                     })
[17:29:40.819]                   }
[17:29:40.819]                   ...future.strategy.old <- future::plan("list")
[17:29:40.819]                   options(future.plan = NULL)
[17:29:40.819]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.819]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:40.819]                 }
[17:29:40.819]                 ...future.workdir <- getwd()
[17:29:40.819]             }
[17:29:40.819]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:40.819]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:40.819]         }
[17:29:40.819]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:40.819]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:40.819]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:40.819]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:40.819]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:40.819]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:40.819]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:40.819]             base::names(...future.oldOptions))
[17:29:40.819]     }
[17:29:40.819]     if (FALSE) {
[17:29:40.819]     }
[17:29:40.819]     else {
[17:29:40.819]         if (TRUE) {
[17:29:40.819]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:40.819]                 open = "w")
[17:29:40.819]         }
[17:29:40.819]         else {
[17:29:40.819]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:40.819]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:40.819]         }
[17:29:40.819]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:40.819]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:40.819]             base::sink(type = "output", split = FALSE)
[17:29:40.819]             base::close(...future.stdout)
[17:29:40.819]         }, add = TRUE)
[17:29:40.819]     }
[17:29:40.819]     ...future.frame <- base::sys.nframe()
[17:29:40.819]     ...future.conditions <- base::list()
[17:29:40.819]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:40.819]     if (FALSE) {
[17:29:40.819]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:40.819]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:40.819]     }
[17:29:40.819]     ...future.result <- base::tryCatch({
[17:29:40.819]         base::withCallingHandlers({
[17:29:40.819]             ...future.value <- base::withVisible(base::local({
[17:29:40.819]                 sample(x, size = 1L)
[17:29:40.819]             }))
[17:29:40.819]             future::FutureResult(value = ...future.value$value, 
[17:29:40.819]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.819]                   ...future.rng), globalenv = if (FALSE) 
[17:29:40.819]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:40.819]                     ...future.globalenv.names))
[17:29:40.819]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:40.819]         }, condition = base::local({
[17:29:40.819]             c <- base::c
[17:29:40.819]             inherits <- base::inherits
[17:29:40.819]             invokeRestart <- base::invokeRestart
[17:29:40.819]             length <- base::length
[17:29:40.819]             list <- base::list
[17:29:40.819]             seq.int <- base::seq.int
[17:29:40.819]             signalCondition <- base::signalCondition
[17:29:40.819]             sys.calls <- base::sys.calls
[17:29:40.819]             `[[` <- base::`[[`
[17:29:40.819]             `+` <- base::`+`
[17:29:40.819]             `<<-` <- base::`<<-`
[17:29:40.819]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:40.819]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:40.819]                   3L)]
[17:29:40.819]             }
[17:29:40.819]             function(cond) {
[17:29:40.819]                 is_error <- inherits(cond, "error")
[17:29:40.819]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:40.819]                   NULL)
[17:29:40.819]                 if (is_error) {
[17:29:40.819]                   sessionInformation <- function() {
[17:29:40.819]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:40.819]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:40.819]                       search = base::search(), system = base::Sys.info())
[17:29:40.819]                   }
[17:29:40.819]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.819]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:40.819]                     cond$call), session = sessionInformation(), 
[17:29:40.819]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:40.819]                   signalCondition(cond)
[17:29:40.819]                 }
[17:29:40.819]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:40.819]                 "immediateCondition"))) {
[17:29:40.819]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:40.819]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.819]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:40.819]                   if (TRUE && !signal) {
[17:29:40.819]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.819]                     {
[17:29:40.819]                       inherits <- base::inherits
[17:29:40.819]                       invokeRestart <- base::invokeRestart
[17:29:40.819]                       is.null <- base::is.null
[17:29:40.819]                       muffled <- FALSE
[17:29:40.819]                       if (inherits(cond, "message")) {
[17:29:40.819]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.819]                         if (muffled) 
[17:29:40.819]                           invokeRestart("muffleMessage")
[17:29:40.819]                       }
[17:29:40.819]                       else if (inherits(cond, "warning")) {
[17:29:40.819]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.819]                         if (muffled) 
[17:29:40.819]                           invokeRestart("muffleWarning")
[17:29:40.819]                       }
[17:29:40.819]                       else if (inherits(cond, "condition")) {
[17:29:40.819]                         if (!is.null(pattern)) {
[17:29:40.819]                           computeRestarts <- base::computeRestarts
[17:29:40.819]                           grepl <- base::grepl
[17:29:40.819]                           restarts <- computeRestarts(cond)
[17:29:40.819]                           for (restart in restarts) {
[17:29:40.819]                             name <- restart$name
[17:29:40.819]                             if (is.null(name)) 
[17:29:40.819]                               next
[17:29:40.819]                             if (!grepl(pattern, name)) 
[17:29:40.819]                               next
[17:29:40.819]                             invokeRestart(restart)
[17:29:40.819]                             muffled <- TRUE
[17:29:40.819]                             break
[17:29:40.819]                           }
[17:29:40.819]                         }
[17:29:40.819]                       }
[17:29:40.819]                       invisible(muffled)
[17:29:40.819]                     }
[17:29:40.819]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.819]                   }
[17:29:40.819]                 }
[17:29:40.819]                 else {
[17:29:40.819]                   if (TRUE) {
[17:29:40.819]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.819]                     {
[17:29:40.819]                       inherits <- base::inherits
[17:29:40.819]                       invokeRestart <- base::invokeRestart
[17:29:40.819]                       is.null <- base::is.null
[17:29:40.819]                       muffled <- FALSE
[17:29:40.819]                       if (inherits(cond, "message")) {
[17:29:40.819]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.819]                         if (muffled) 
[17:29:40.819]                           invokeRestart("muffleMessage")
[17:29:40.819]                       }
[17:29:40.819]                       else if (inherits(cond, "warning")) {
[17:29:40.819]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.819]                         if (muffled) 
[17:29:40.819]                           invokeRestart("muffleWarning")
[17:29:40.819]                       }
[17:29:40.819]                       else if (inherits(cond, "condition")) {
[17:29:40.819]                         if (!is.null(pattern)) {
[17:29:40.819]                           computeRestarts <- base::computeRestarts
[17:29:40.819]                           grepl <- base::grepl
[17:29:40.819]                           restarts <- computeRestarts(cond)
[17:29:40.819]                           for (restart in restarts) {
[17:29:40.819]                             name <- restart$name
[17:29:40.819]                             if (is.null(name)) 
[17:29:40.819]                               next
[17:29:40.819]                             if (!grepl(pattern, name)) 
[17:29:40.819]                               next
[17:29:40.819]                             invokeRestart(restart)
[17:29:40.819]                             muffled <- TRUE
[17:29:40.819]                             break
[17:29:40.819]                           }
[17:29:40.819]                         }
[17:29:40.819]                       }
[17:29:40.819]                       invisible(muffled)
[17:29:40.819]                     }
[17:29:40.819]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.819]                   }
[17:29:40.819]                 }
[17:29:40.819]             }
[17:29:40.819]         }))
[17:29:40.819]     }, error = function(ex) {
[17:29:40.819]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:40.819]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.819]                 ...future.rng), started = ...future.startTime, 
[17:29:40.819]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:40.819]             version = "1.8"), class = "FutureResult")
[17:29:40.819]     }, finally = {
[17:29:40.819]         if (!identical(...future.workdir, getwd())) 
[17:29:40.819]             setwd(...future.workdir)
[17:29:40.819]         {
[17:29:40.819]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:40.819]                 ...future.oldOptions$nwarnings <- NULL
[17:29:40.819]             }
[17:29:40.819]             base::options(...future.oldOptions)
[17:29:40.819]             if (.Platform$OS.type == "windows") {
[17:29:40.819]                 old_names <- names(...future.oldEnvVars)
[17:29:40.819]                 envs <- base::Sys.getenv()
[17:29:40.819]                 names <- names(envs)
[17:29:40.819]                 common <- intersect(names, old_names)
[17:29:40.819]                 added <- setdiff(names, old_names)
[17:29:40.819]                 removed <- setdiff(old_names, names)
[17:29:40.819]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:40.819]                   envs[common]]
[17:29:40.819]                 NAMES <- toupper(changed)
[17:29:40.819]                 args <- list()
[17:29:40.819]                 for (kk in seq_along(NAMES)) {
[17:29:40.819]                   name <- changed[[kk]]
[17:29:40.819]                   NAME <- NAMES[[kk]]
[17:29:40.819]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.819]                     next
[17:29:40.819]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.819]                 }
[17:29:40.819]                 NAMES <- toupper(added)
[17:29:40.819]                 for (kk in seq_along(NAMES)) {
[17:29:40.819]                   name <- added[[kk]]
[17:29:40.819]                   NAME <- NAMES[[kk]]
[17:29:40.819]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.819]                     next
[17:29:40.819]                   args[[name]] <- ""
[17:29:40.819]                 }
[17:29:40.819]                 NAMES <- toupper(removed)
[17:29:40.819]                 for (kk in seq_along(NAMES)) {
[17:29:40.819]                   name <- removed[[kk]]
[17:29:40.819]                   NAME <- NAMES[[kk]]
[17:29:40.819]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.819]                     next
[17:29:40.819]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.819]                 }
[17:29:40.819]                 if (length(args) > 0) 
[17:29:40.819]                   base::do.call(base::Sys.setenv, args = args)
[17:29:40.819]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:40.819]             }
[17:29:40.819]             else {
[17:29:40.819]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:40.819]             }
[17:29:40.819]             {
[17:29:40.819]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:40.819]                   0L) {
[17:29:40.819]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:40.819]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:40.819]                   base::options(opts)
[17:29:40.819]                 }
[17:29:40.819]                 {
[17:29:40.819]                   {
[17:29:40.819]                     base::assign(".Random.seed", c(10407L, 947362787L, 
[17:29:40.819]                     719126051L, -2135816529L, 855306454L, 1265414195L, 
[17:29:40.819]                     1336165471L), envir = base::globalenv(), 
[17:29:40.819]                       inherits = FALSE)
[17:29:40.819]                     NULL
[17:29:40.819]                   }
[17:29:40.819]                   options(future.plan = NULL)
[17:29:40.819]                   if (is.na(NA_character_)) 
[17:29:40.819]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.819]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:40.819]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:40.819]                     .init = FALSE)
[17:29:40.819]                 }
[17:29:40.819]             }
[17:29:40.819]         }
[17:29:40.819]     })
[17:29:40.819]     if (TRUE) {
[17:29:40.819]         base::sink(type = "output", split = FALSE)
[17:29:40.819]         if (TRUE) {
[17:29:40.819]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:40.819]         }
[17:29:40.819]         else {
[17:29:40.819]             ...future.result["stdout"] <- base::list(NULL)
[17:29:40.819]         }
[17:29:40.819]         base::close(...future.stdout)
[17:29:40.819]         ...future.stdout <- NULL
[17:29:40.819]     }
[17:29:40.819]     ...future.result$conditions <- ...future.conditions
[17:29:40.819]     ...future.result$finished <- base::Sys.time()
[17:29:40.819]     ...future.result
[17:29:40.819] }
[17:29:40.825] assign_globals() ...
[17:29:40.825] List of 1
[17:29:40.825]  $ x: int [1:4] 0 1 2 3
[17:29:40.825]  - attr(*, "where")=List of 1
[17:29:40.825]   ..$ x:<environment: R_EmptyEnv> 
[17:29:40.825]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:40.825]  - attr(*, "resolved")= logi FALSE
[17:29:40.825]  - attr(*, "total_size")= int 133
[17:29:40.825]  - attr(*, "already-done")= logi TRUE
[17:29:40.830] - copied 'x' to environment
[17:29:40.831] assign_globals() ... done
[17:29:40.831] plan(): Setting new future strategy stack:
[17:29:40.831] List of future strategies:
[17:29:40.831] 1. sequential:
[17:29:40.831]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.831]    - tweaked: FALSE
[17:29:40.831]    - call: NULL
[17:29:40.832] plan(): nbrOfWorkers() = 1
[17:29:40.834] plan(): Setting new future strategy stack:
[17:29:40.835] List of future strategies:
[17:29:40.835] 1. sequential:
[17:29:40.835]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.835]    - tweaked: FALSE
[17:29:40.835]    - call: plan(strategy)
[17:29:40.836] plan(): nbrOfWorkers() = 1
[17:29:40.836] SequentialFuture started (and completed)
[17:29:40.836] - Launch lazy future ... done
[17:29:40.837] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_1-12558'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add7c6c028
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.839] getGlobalsAndPackages() ...
[17:29:40.839] Searching for globals...
[17:29:40.841] - globals found: [3] '{', 'sample', 'x'
[17:29:40.841] Searching for globals ... DONE
[17:29:40.841] Resolving globals: FALSE
[17:29:40.842] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:40.843] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:40.843] - globals: [1] 'x'
[17:29:40.843] 
[17:29:40.844] getGlobalsAndPackages() ... DONE
[17:29:40.844] run() for 'Future' ...
[17:29:40.845] - state: 'created'
[17:29:40.845] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:40.846] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.846] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:40.846]   - Field: 'label'
[17:29:40.846]   - Field: 'local'
[17:29:40.847]   - Field: 'owner'
[17:29:40.847]   - Field: 'envir'
[17:29:40.847]   - Field: 'packages'
[17:29:40.848]   - Field: 'gc'
[17:29:40.849]   - Field: 'conditions'
[17:29:40.849]   - Field: 'expr'
[17:29:40.849]   - Field: 'uuid'
[17:29:40.850]   - Field: 'seed'
[17:29:40.850]   - Field: 'version'
[17:29:40.850]   - Field: 'result'
[17:29:40.851]   - Field: 'asynchronous'
[17:29:40.851]   - Field: 'calls'
[17:29:40.851]   - Field: 'globals'
[17:29:40.852]   - Field: 'stdout'
[17:29:40.852]   - Field: 'earlySignal'
[17:29:40.852]   - Field: 'lazy'
[17:29:40.853]   - Field: 'state'
[17:29:40.853] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:40.853] - Launch lazy future ...
[17:29:40.854] Packages needed by the future expression (n = 0): <none>
[17:29:40.854] Packages needed by future strategies (n = 0): <none>
[17:29:40.855] {
[17:29:40.855]     {
[17:29:40.855]         {
[17:29:40.855]             ...future.startTime <- base::Sys.time()
[17:29:40.855]             {
[17:29:40.855]                 {
[17:29:40.855]                   {
[17:29:40.855]                     base::local({
[17:29:40.855]                       has_future <- base::requireNamespace("future", 
[17:29:40.855]                         quietly = TRUE)
[17:29:40.855]                       if (has_future) {
[17:29:40.855]                         ns <- base::getNamespace("future")
[17:29:40.855]                         version <- ns[[".package"]][["version"]]
[17:29:40.855]                         if (is.null(version)) 
[17:29:40.855]                           version <- utils::packageVersion("future")
[17:29:40.855]                       }
[17:29:40.855]                       else {
[17:29:40.855]                         version <- NULL
[17:29:40.855]                       }
[17:29:40.855]                       if (!has_future || version < "1.8.0") {
[17:29:40.855]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:40.855]                           "", base::R.version$version.string), 
[17:29:40.855]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:40.855]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:40.855]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:40.855]                             "release", "version")], collapse = " "), 
[17:29:40.855]                           hostname = base::Sys.info()[["nodename"]])
[17:29:40.855]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:40.855]                           info)
[17:29:40.855]                         info <- base::paste(info, collapse = "; ")
[17:29:40.855]                         if (!has_future) {
[17:29:40.855]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:40.855]                             info)
[17:29:40.855]                         }
[17:29:40.855]                         else {
[17:29:40.855]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:40.855]                             info, version)
[17:29:40.855]                         }
[17:29:40.855]                         base::stop(msg)
[17:29:40.855]                       }
[17:29:40.855]                     })
[17:29:40.855]                   }
[17:29:40.855]                   ...future.strategy.old <- future::plan("list")
[17:29:40.855]                   options(future.plan = NULL)
[17:29:40.855]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.855]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:40.855]                 }
[17:29:40.855]                 ...future.workdir <- getwd()
[17:29:40.855]             }
[17:29:40.855]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:40.855]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:40.855]         }
[17:29:40.855]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:40.855]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:40.855]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:40.855]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:40.855]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:40.855]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:40.855]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:40.855]             base::names(...future.oldOptions))
[17:29:40.855]     }
[17:29:40.855]     if (FALSE) {
[17:29:40.855]     }
[17:29:40.855]     else {
[17:29:40.855]         if (TRUE) {
[17:29:40.855]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:40.855]                 open = "w")
[17:29:40.855]         }
[17:29:40.855]         else {
[17:29:40.855]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:40.855]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:40.855]         }
[17:29:40.855]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:40.855]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:40.855]             base::sink(type = "output", split = FALSE)
[17:29:40.855]             base::close(...future.stdout)
[17:29:40.855]         }, add = TRUE)
[17:29:40.855]     }
[17:29:40.855]     ...future.frame <- base::sys.nframe()
[17:29:40.855]     ...future.conditions <- base::list()
[17:29:40.855]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:40.855]     if (FALSE) {
[17:29:40.855]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:40.855]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:40.855]     }
[17:29:40.855]     ...future.result <- base::tryCatch({
[17:29:40.855]         base::withCallingHandlers({
[17:29:40.855]             ...future.value <- base::withVisible(base::local({
[17:29:40.855]                 sample(x, size = 1L)
[17:29:40.855]             }))
[17:29:40.855]             future::FutureResult(value = ...future.value$value, 
[17:29:40.855]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.855]                   ...future.rng), globalenv = if (FALSE) 
[17:29:40.855]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:40.855]                     ...future.globalenv.names))
[17:29:40.855]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:40.855]         }, condition = base::local({
[17:29:40.855]             c <- base::c
[17:29:40.855]             inherits <- base::inherits
[17:29:40.855]             invokeRestart <- base::invokeRestart
[17:29:40.855]             length <- base::length
[17:29:40.855]             list <- base::list
[17:29:40.855]             seq.int <- base::seq.int
[17:29:40.855]             signalCondition <- base::signalCondition
[17:29:40.855]             sys.calls <- base::sys.calls
[17:29:40.855]             `[[` <- base::`[[`
[17:29:40.855]             `+` <- base::`+`
[17:29:40.855]             `<<-` <- base::`<<-`
[17:29:40.855]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:40.855]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:40.855]                   3L)]
[17:29:40.855]             }
[17:29:40.855]             function(cond) {
[17:29:40.855]                 is_error <- inherits(cond, "error")
[17:29:40.855]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:40.855]                   NULL)
[17:29:40.855]                 if (is_error) {
[17:29:40.855]                   sessionInformation <- function() {
[17:29:40.855]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:40.855]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:40.855]                       search = base::search(), system = base::Sys.info())
[17:29:40.855]                   }
[17:29:40.855]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.855]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:40.855]                     cond$call), session = sessionInformation(), 
[17:29:40.855]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:40.855]                   signalCondition(cond)
[17:29:40.855]                 }
[17:29:40.855]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:40.855]                 "immediateCondition"))) {
[17:29:40.855]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:40.855]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.855]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:40.855]                   if (TRUE && !signal) {
[17:29:40.855]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.855]                     {
[17:29:40.855]                       inherits <- base::inherits
[17:29:40.855]                       invokeRestart <- base::invokeRestart
[17:29:40.855]                       is.null <- base::is.null
[17:29:40.855]                       muffled <- FALSE
[17:29:40.855]                       if (inherits(cond, "message")) {
[17:29:40.855]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.855]                         if (muffled) 
[17:29:40.855]                           invokeRestart("muffleMessage")
[17:29:40.855]                       }
[17:29:40.855]                       else if (inherits(cond, "warning")) {
[17:29:40.855]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.855]                         if (muffled) 
[17:29:40.855]                           invokeRestart("muffleWarning")
[17:29:40.855]                       }
[17:29:40.855]                       else if (inherits(cond, "condition")) {
[17:29:40.855]                         if (!is.null(pattern)) {
[17:29:40.855]                           computeRestarts <- base::computeRestarts
[17:29:40.855]                           grepl <- base::grepl
[17:29:40.855]                           restarts <- computeRestarts(cond)
[17:29:40.855]                           for (restart in restarts) {
[17:29:40.855]                             name <- restart$name
[17:29:40.855]                             if (is.null(name)) 
[17:29:40.855]                               next
[17:29:40.855]                             if (!grepl(pattern, name)) 
[17:29:40.855]                               next
[17:29:40.855]                             invokeRestart(restart)
[17:29:40.855]                             muffled <- TRUE
[17:29:40.855]                             break
[17:29:40.855]                           }
[17:29:40.855]                         }
[17:29:40.855]                       }
[17:29:40.855]                       invisible(muffled)
[17:29:40.855]                     }
[17:29:40.855]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.855]                   }
[17:29:40.855]                 }
[17:29:40.855]                 else {
[17:29:40.855]                   if (TRUE) {
[17:29:40.855]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.855]                     {
[17:29:40.855]                       inherits <- base::inherits
[17:29:40.855]                       invokeRestart <- base::invokeRestart
[17:29:40.855]                       is.null <- base::is.null
[17:29:40.855]                       muffled <- FALSE
[17:29:40.855]                       if (inherits(cond, "message")) {
[17:29:40.855]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.855]                         if (muffled) 
[17:29:40.855]                           invokeRestart("muffleMessage")
[17:29:40.855]                       }
[17:29:40.855]                       else if (inherits(cond, "warning")) {
[17:29:40.855]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.855]                         if (muffled) 
[17:29:40.855]                           invokeRestart("muffleWarning")
[17:29:40.855]                       }
[17:29:40.855]                       else if (inherits(cond, "condition")) {
[17:29:40.855]                         if (!is.null(pattern)) {
[17:29:40.855]                           computeRestarts <- base::computeRestarts
[17:29:40.855]                           grepl <- base::grepl
[17:29:40.855]                           restarts <- computeRestarts(cond)
[17:29:40.855]                           for (restart in restarts) {
[17:29:40.855]                             name <- restart$name
[17:29:40.855]                             if (is.null(name)) 
[17:29:40.855]                               next
[17:29:40.855]                             if (!grepl(pattern, name)) 
[17:29:40.855]                               next
[17:29:40.855]                             invokeRestart(restart)
[17:29:40.855]                             muffled <- TRUE
[17:29:40.855]                             break
[17:29:40.855]                           }
[17:29:40.855]                         }
[17:29:40.855]                       }
[17:29:40.855]                       invisible(muffled)
[17:29:40.855]                     }
[17:29:40.855]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.855]                   }
[17:29:40.855]                 }
[17:29:40.855]             }
[17:29:40.855]         }))
[17:29:40.855]     }, error = function(ex) {
[17:29:40.855]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:40.855]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.855]                 ...future.rng), started = ...future.startTime, 
[17:29:40.855]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:40.855]             version = "1.8"), class = "FutureResult")
[17:29:40.855]     }, finally = {
[17:29:40.855]         if (!identical(...future.workdir, getwd())) 
[17:29:40.855]             setwd(...future.workdir)
[17:29:40.855]         {
[17:29:40.855]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:40.855]                 ...future.oldOptions$nwarnings <- NULL
[17:29:40.855]             }
[17:29:40.855]             base::options(...future.oldOptions)
[17:29:40.855]             if (.Platform$OS.type == "windows") {
[17:29:40.855]                 old_names <- names(...future.oldEnvVars)
[17:29:40.855]                 envs <- base::Sys.getenv()
[17:29:40.855]                 names <- names(envs)
[17:29:40.855]                 common <- intersect(names, old_names)
[17:29:40.855]                 added <- setdiff(names, old_names)
[17:29:40.855]                 removed <- setdiff(old_names, names)
[17:29:40.855]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:40.855]                   envs[common]]
[17:29:40.855]                 NAMES <- toupper(changed)
[17:29:40.855]                 args <- list()
[17:29:40.855]                 for (kk in seq_along(NAMES)) {
[17:29:40.855]                   name <- changed[[kk]]
[17:29:40.855]                   NAME <- NAMES[[kk]]
[17:29:40.855]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.855]                     next
[17:29:40.855]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.855]                 }
[17:29:40.855]                 NAMES <- toupper(added)
[17:29:40.855]                 for (kk in seq_along(NAMES)) {
[17:29:40.855]                   name <- added[[kk]]
[17:29:40.855]                   NAME <- NAMES[[kk]]
[17:29:40.855]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.855]                     next
[17:29:40.855]                   args[[name]] <- ""
[17:29:40.855]                 }
[17:29:40.855]                 NAMES <- toupper(removed)
[17:29:40.855]                 for (kk in seq_along(NAMES)) {
[17:29:40.855]                   name <- removed[[kk]]
[17:29:40.855]                   NAME <- NAMES[[kk]]
[17:29:40.855]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.855]                     next
[17:29:40.855]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.855]                 }
[17:29:40.855]                 if (length(args) > 0) 
[17:29:40.855]                   base::do.call(base::Sys.setenv, args = args)
[17:29:40.855]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:40.855]             }
[17:29:40.855]             else {
[17:29:40.855]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:40.855]             }
[17:29:40.855]             {
[17:29:40.855]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:40.855]                   0L) {
[17:29:40.855]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:40.855]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:40.855]                   base::options(opts)
[17:29:40.855]                 }
[17:29:40.855]                 {
[17:29:40.855]                   {
[17:29:40.855]                     base::assign(".Random.seed", c(10407L, -2135816529L, 
[17:29:40.855]                     1859168897L, -440760210L, 1336165471L, 1864291132L, 
[17:29:40.855]                     -1294538296L), envir = base::globalenv(), 
[17:29:40.855]                       inherits = FALSE)
[17:29:40.855]                     NULL
[17:29:40.855]                   }
[17:29:40.855]                   options(future.plan = NULL)
[17:29:40.855]                   if (is.na(NA_character_)) 
[17:29:40.855]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.855]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:40.855]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:40.855]                     .init = FALSE)
[17:29:40.855]                 }
[17:29:40.855]             }
[17:29:40.855]         }
[17:29:40.855]     })
[17:29:40.855]     if (TRUE) {
[17:29:40.855]         base::sink(type = "output", split = FALSE)
[17:29:40.855]         if (TRUE) {
[17:29:40.855]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:40.855]         }
[17:29:40.855]         else {
[17:29:40.855]             ...future.result["stdout"] <- base::list(NULL)
[17:29:40.855]         }
[17:29:40.855]         base::close(...future.stdout)
[17:29:40.855]         ...future.stdout <- NULL
[17:29:40.855]     }
[17:29:40.855]     ...future.result$conditions <- ...future.conditions
[17:29:40.855]     ...future.result$finished <- base::Sys.time()
[17:29:40.855]     ...future.result
[17:29:40.855] }
[17:29:40.861] assign_globals() ...
[17:29:40.862] List of 1
[17:29:40.862]  $ x: int [1:4] 0 1 2 3
[17:29:40.862]  - attr(*, "where")=List of 1
[17:29:40.862]   ..$ x:<environment: R_EmptyEnv> 
[17:29:40.862]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:40.862]  - attr(*, "resolved")= logi FALSE
[17:29:40.862]  - attr(*, "total_size")= int 133
[17:29:40.862]  - attr(*, "already-done")= logi TRUE
[17:29:40.871] - copied 'x' to environment
[17:29:40.871] assign_globals() ... done
[17:29:40.872] plan(): Setting new future strategy stack:
[17:29:40.872] List of future strategies:
[17:29:40.872] 1. sequential:
[17:29:40.872]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.872]    - tweaked: FALSE
[17:29:40.872]    - call: NULL
[17:29:40.873] plan(): nbrOfWorkers() = 1
[17:29:40.875] plan(): Setting new future strategy stack:
[17:29:40.876] List of future strategies:
[17:29:40.876] 1. sequential:
[17:29:40.876]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.876]    - tweaked: FALSE
[17:29:40.876]    - call: plan(strategy)
[17:29:40.877] plan(): nbrOfWorkers() = 1
[17:29:40.877] SequentialFuture started (and completed)
[17:29:40.877] - Launch lazy future ... done
[17:29:40.878] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_2-78564'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add7c6c028
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.880] getGlobalsAndPackages() ...
[17:29:40.880] Searching for globals...
[17:29:40.882] - globals found: [3] '{', 'sample', 'x'
[17:29:40.882] Searching for globals ... DONE
[17:29:40.883] Resolving globals: FALSE
[17:29:40.884] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:40.884] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:40.885] - globals: [1] 'x'
[17:29:40.885] 
[17:29:40.885] getGlobalsAndPackages() ... DONE
[17:29:40.886] run() for 'Future' ...
[17:29:40.886] - state: 'created'
[17:29:40.887] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:40.887] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.888] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:40.888]   - Field: 'label'
[17:29:40.888]   - Field: 'local'
[17:29:40.889]   - Field: 'owner'
[17:29:40.889]   - Field: 'envir'
[17:29:40.889]   - Field: 'packages'
[17:29:40.890]   - Field: 'gc'
[17:29:40.890]   - Field: 'conditions'
[17:29:40.890]   - Field: 'expr'
[17:29:40.890]   - Field: 'uuid'
[17:29:40.891]   - Field: 'seed'
[17:29:40.891]   - Field: 'version'
[17:29:40.891]   - Field: 'result'
[17:29:40.892]   - Field: 'asynchronous'
[17:29:40.892]   - Field: 'calls'
[17:29:40.892]   - Field: 'globals'
[17:29:40.893]   - Field: 'stdout'
[17:29:40.893]   - Field: 'earlySignal'
[17:29:40.893]   - Field: 'lazy'
[17:29:40.894]   - Field: 'state'
[17:29:40.894] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:40.894] - Launch lazy future ...
[17:29:40.895] Packages needed by the future expression (n = 0): <none>
[17:29:40.895] Packages needed by future strategies (n = 0): <none>
[17:29:40.896] {
[17:29:40.896]     {
[17:29:40.896]         {
[17:29:40.896]             ...future.startTime <- base::Sys.time()
[17:29:40.896]             {
[17:29:40.896]                 {
[17:29:40.896]                   {
[17:29:40.896]                     base::local({
[17:29:40.896]                       has_future <- base::requireNamespace("future", 
[17:29:40.896]                         quietly = TRUE)
[17:29:40.896]                       if (has_future) {
[17:29:40.896]                         ns <- base::getNamespace("future")
[17:29:40.896]                         version <- ns[[".package"]][["version"]]
[17:29:40.896]                         if (is.null(version)) 
[17:29:40.896]                           version <- utils::packageVersion("future")
[17:29:40.896]                       }
[17:29:40.896]                       else {
[17:29:40.896]                         version <- NULL
[17:29:40.896]                       }
[17:29:40.896]                       if (!has_future || version < "1.8.0") {
[17:29:40.896]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:40.896]                           "", base::R.version$version.string), 
[17:29:40.896]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:40.896]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:40.896]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:40.896]                             "release", "version")], collapse = " "), 
[17:29:40.896]                           hostname = base::Sys.info()[["nodename"]])
[17:29:40.896]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:40.896]                           info)
[17:29:40.896]                         info <- base::paste(info, collapse = "; ")
[17:29:40.896]                         if (!has_future) {
[17:29:40.896]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:40.896]                             info)
[17:29:40.896]                         }
[17:29:40.896]                         else {
[17:29:40.896]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:40.896]                             info, version)
[17:29:40.896]                         }
[17:29:40.896]                         base::stop(msg)
[17:29:40.896]                       }
[17:29:40.896]                     })
[17:29:40.896]                   }
[17:29:40.896]                   ...future.strategy.old <- future::plan("list")
[17:29:40.896]                   options(future.plan = NULL)
[17:29:40.896]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.896]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:40.896]                 }
[17:29:40.896]                 ...future.workdir <- getwd()
[17:29:40.896]             }
[17:29:40.896]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:40.896]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:40.896]         }
[17:29:40.896]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:40.896]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:40.896]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:40.896]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:40.896]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:40.896]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:40.896]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:40.896]             base::names(...future.oldOptions))
[17:29:40.896]     }
[17:29:40.896]     if (FALSE) {
[17:29:40.896]     }
[17:29:40.896]     else {
[17:29:40.896]         if (TRUE) {
[17:29:40.896]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:40.896]                 open = "w")
[17:29:40.896]         }
[17:29:40.896]         else {
[17:29:40.896]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:40.896]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:40.896]         }
[17:29:40.896]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:40.896]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:40.896]             base::sink(type = "output", split = FALSE)
[17:29:40.896]             base::close(...future.stdout)
[17:29:40.896]         }, add = TRUE)
[17:29:40.896]     }
[17:29:40.896]     ...future.frame <- base::sys.nframe()
[17:29:40.896]     ...future.conditions <- base::list()
[17:29:40.896]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:40.896]     if (FALSE) {
[17:29:40.896]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:40.896]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:40.896]     }
[17:29:40.896]     ...future.result <- base::tryCatch({
[17:29:40.896]         base::withCallingHandlers({
[17:29:40.896]             ...future.value <- base::withVisible(base::local({
[17:29:40.896]                 sample(x, size = 1L)
[17:29:40.896]             }))
[17:29:40.896]             future::FutureResult(value = ...future.value$value, 
[17:29:40.896]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.896]                   ...future.rng), globalenv = if (FALSE) 
[17:29:40.896]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:40.896]                     ...future.globalenv.names))
[17:29:40.896]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:40.896]         }, condition = base::local({
[17:29:40.896]             c <- base::c
[17:29:40.896]             inherits <- base::inherits
[17:29:40.896]             invokeRestart <- base::invokeRestart
[17:29:40.896]             length <- base::length
[17:29:40.896]             list <- base::list
[17:29:40.896]             seq.int <- base::seq.int
[17:29:40.896]             signalCondition <- base::signalCondition
[17:29:40.896]             sys.calls <- base::sys.calls
[17:29:40.896]             `[[` <- base::`[[`
[17:29:40.896]             `+` <- base::`+`
[17:29:40.896]             `<<-` <- base::`<<-`
[17:29:40.896]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:40.896]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:40.896]                   3L)]
[17:29:40.896]             }
[17:29:40.896]             function(cond) {
[17:29:40.896]                 is_error <- inherits(cond, "error")
[17:29:40.896]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:40.896]                   NULL)
[17:29:40.896]                 if (is_error) {
[17:29:40.896]                   sessionInformation <- function() {
[17:29:40.896]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:40.896]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:40.896]                       search = base::search(), system = base::Sys.info())
[17:29:40.896]                   }
[17:29:40.896]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.896]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:40.896]                     cond$call), session = sessionInformation(), 
[17:29:40.896]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:40.896]                   signalCondition(cond)
[17:29:40.896]                 }
[17:29:40.896]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:40.896]                 "immediateCondition"))) {
[17:29:40.896]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:40.896]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.896]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:40.896]                   if (TRUE && !signal) {
[17:29:40.896]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.896]                     {
[17:29:40.896]                       inherits <- base::inherits
[17:29:40.896]                       invokeRestart <- base::invokeRestart
[17:29:40.896]                       is.null <- base::is.null
[17:29:40.896]                       muffled <- FALSE
[17:29:40.896]                       if (inherits(cond, "message")) {
[17:29:40.896]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.896]                         if (muffled) 
[17:29:40.896]                           invokeRestart("muffleMessage")
[17:29:40.896]                       }
[17:29:40.896]                       else if (inherits(cond, "warning")) {
[17:29:40.896]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.896]                         if (muffled) 
[17:29:40.896]                           invokeRestart("muffleWarning")
[17:29:40.896]                       }
[17:29:40.896]                       else if (inherits(cond, "condition")) {
[17:29:40.896]                         if (!is.null(pattern)) {
[17:29:40.896]                           computeRestarts <- base::computeRestarts
[17:29:40.896]                           grepl <- base::grepl
[17:29:40.896]                           restarts <- computeRestarts(cond)
[17:29:40.896]                           for (restart in restarts) {
[17:29:40.896]                             name <- restart$name
[17:29:40.896]                             if (is.null(name)) 
[17:29:40.896]                               next
[17:29:40.896]                             if (!grepl(pattern, name)) 
[17:29:40.896]                               next
[17:29:40.896]                             invokeRestart(restart)
[17:29:40.896]                             muffled <- TRUE
[17:29:40.896]                             break
[17:29:40.896]                           }
[17:29:40.896]                         }
[17:29:40.896]                       }
[17:29:40.896]                       invisible(muffled)
[17:29:40.896]                     }
[17:29:40.896]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.896]                   }
[17:29:40.896]                 }
[17:29:40.896]                 else {
[17:29:40.896]                   if (TRUE) {
[17:29:40.896]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.896]                     {
[17:29:40.896]                       inherits <- base::inherits
[17:29:40.896]                       invokeRestart <- base::invokeRestart
[17:29:40.896]                       is.null <- base::is.null
[17:29:40.896]                       muffled <- FALSE
[17:29:40.896]                       if (inherits(cond, "message")) {
[17:29:40.896]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.896]                         if (muffled) 
[17:29:40.896]                           invokeRestart("muffleMessage")
[17:29:40.896]                       }
[17:29:40.896]                       else if (inherits(cond, "warning")) {
[17:29:40.896]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.896]                         if (muffled) 
[17:29:40.896]                           invokeRestart("muffleWarning")
[17:29:40.896]                       }
[17:29:40.896]                       else if (inherits(cond, "condition")) {
[17:29:40.896]                         if (!is.null(pattern)) {
[17:29:40.896]                           computeRestarts <- base::computeRestarts
[17:29:40.896]                           grepl <- base::grepl
[17:29:40.896]                           restarts <- computeRestarts(cond)
[17:29:40.896]                           for (restart in restarts) {
[17:29:40.896]                             name <- restart$name
[17:29:40.896]                             if (is.null(name)) 
[17:29:40.896]                               next
[17:29:40.896]                             if (!grepl(pattern, name)) 
[17:29:40.896]                               next
[17:29:40.896]                             invokeRestart(restart)
[17:29:40.896]                             muffled <- TRUE
[17:29:40.896]                             break
[17:29:40.896]                           }
[17:29:40.896]                         }
[17:29:40.896]                       }
[17:29:40.896]                       invisible(muffled)
[17:29:40.896]                     }
[17:29:40.896]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.896]                   }
[17:29:40.896]                 }
[17:29:40.896]             }
[17:29:40.896]         }))
[17:29:40.896]     }, error = function(ex) {
[17:29:40.896]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:40.896]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.896]                 ...future.rng), started = ...future.startTime, 
[17:29:40.896]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:40.896]             version = "1.8"), class = "FutureResult")
[17:29:40.896]     }, finally = {
[17:29:40.896]         if (!identical(...future.workdir, getwd())) 
[17:29:40.896]             setwd(...future.workdir)
[17:29:40.896]         {
[17:29:40.896]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:40.896]                 ...future.oldOptions$nwarnings <- NULL
[17:29:40.896]             }
[17:29:40.896]             base::options(...future.oldOptions)
[17:29:40.896]             if (.Platform$OS.type == "windows") {
[17:29:40.896]                 old_names <- names(...future.oldEnvVars)
[17:29:40.896]                 envs <- base::Sys.getenv()
[17:29:40.896]                 names <- names(envs)
[17:29:40.896]                 common <- intersect(names, old_names)
[17:29:40.896]                 added <- setdiff(names, old_names)
[17:29:40.896]                 removed <- setdiff(old_names, names)
[17:29:40.896]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:40.896]                   envs[common]]
[17:29:40.896]                 NAMES <- toupper(changed)
[17:29:40.896]                 args <- list()
[17:29:40.896]                 for (kk in seq_along(NAMES)) {
[17:29:40.896]                   name <- changed[[kk]]
[17:29:40.896]                   NAME <- NAMES[[kk]]
[17:29:40.896]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.896]                     next
[17:29:40.896]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.896]                 }
[17:29:40.896]                 NAMES <- toupper(added)
[17:29:40.896]                 for (kk in seq_along(NAMES)) {
[17:29:40.896]                   name <- added[[kk]]
[17:29:40.896]                   NAME <- NAMES[[kk]]
[17:29:40.896]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.896]                     next
[17:29:40.896]                   args[[name]] <- ""
[17:29:40.896]                 }
[17:29:40.896]                 NAMES <- toupper(removed)
[17:29:40.896]                 for (kk in seq_along(NAMES)) {
[17:29:40.896]                   name <- removed[[kk]]
[17:29:40.896]                   NAME <- NAMES[[kk]]
[17:29:40.896]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.896]                     next
[17:29:40.896]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.896]                 }
[17:29:40.896]                 if (length(args) > 0) 
[17:29:40.896]                   base::do.call(base::Sys.setenv, args = args)
[17:29:40.896]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:40.896]             }
[17:29:40.896]             else {
[17:29:40.896]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:40.896]             }
[17:29:40.896]             {
[17:29:40.896]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:40.896]                   0L) {
[17:29:40.896]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:40.896]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:40.896]                   base::options(opts)
[17:29:40.896]                 }
[17:29:40.896]                 {
[17:29:40.896]                   {
[17:29:40.896]                     base::assign(".Random.seed", c(10407L, -440760210L, 
[17:29:40.896]                     1995121623L, 604992664L, -1294538296L, -2087679657L, 
[17:29:40.896]                     1574614759L), envir = base::globalenv(), 
[17:29:40.896]                       inherits = FALSE)
[17:29:40.896]                     NULL
[17:29:40.896]                   }
[17:29:40.896]                   options(future.plan = NULL)
[17:29:40.896]                   if (is.na(NA_character_)) 
[17:29:40.896]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.896]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:40.896]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:40.896]                     .init = FALSE)
[17:29:40.896]                 }
[17:29:40.896]             }
[17:29:40.896]         }
[17:29:40.896]     })
[17:29:40.896]     if (TRUE) {
[17:29:40.896]         base::sink(type = "output", split = FALSE)
[17:29:40.896]         if (TRUE) {
[17:29:40.896]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:40.896]         }
[17:29:40.896]         else {
[17:29:40.896]             ...future.result["stdout"] <- base::list(NULL)
[17:29:40.896]         }
[17:29:40.896]         base::close(...future.stdout)
[17:29:40.896]         ...future.stdout <- NULL
[17:29:40.896]     }
[17:29:40.896]     ...future.result$conditions <- ...future.conditions
[17:29:40.896]     ...future.result$finished <- base::Sys.time()
[17:29:40.896]     ...future.result
[17:29:40.896] }
[17:29:40.902] assign_globals() ...
[17:29:40.902] List of 1
[17:29:40.902]  $ x: int [1:4] 0 1 2 3
[17:29:40.902]  - attr(*, "where")=List of 1
[17:29:40.902]   ..$ x:<environment: R_EmptyEnv> 
[17:29:40.902]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:40.902]  - attr(*, "resolved")= logi FALSE
[17:29:40.902]  - attr(*, "total_size")= int 133
[17:29:40.902]  - attr(*, "already-done")= logi TRUE
[17:29:40.908] - copied 'x' to environment
[17:29:40.908] assign_globals() ... done
[17:29:40.909] plan(): Setting new future strategy stack:
[17:29:40.909] List of future strategies:
[17:29:40.909] 1. sequential:
[17:29:40.909]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.909]    - tweaked: FALSE
[17:29:40.909]    - call: NULL
[17:29:40.910] plan(): nbrOfWorkers() = 1
[17:29:40.912] plan(): Setting new future strategy stack:
[17:29:40.913] List of future strategies:
[17:29:40.913] 1. sequential:
[17:29:40.913]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.913]    - tweaked: FALSE
[17:29:40.913]    - call: plan(strategy)
[17:29:40.914] plan(): nbrOfWorkers() = 1
[17:29:40.914] SequentialFuture started (and completed)
[17:29:40.915] - Launch lazy future ... done
[17:29:40.915] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_3-706101'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add7c6c028
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.917] getGlobalsAndPackages() ...
[17:29:40.917] Searching for globals...
[17:29:40.922] - globals found: [3] '{', 'sample', 'x'
[17:29:40.923] Searching for globals ... DONE
[17:29:40.923] Resolving globals: FALSE
[17:29:40.924] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:40.925] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:40.925] - globals: [1] 'x'
[17:29:40.925] 
[17:29:40.926] getGlobalsAndPackages() ... DONE
[17:29:40.926] run() for 'Future' ...
[17:29:40.926] - state: 'created'
[17:29:40.927] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:40.928] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.928] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:40.928]   - Field: 'label'
[17:29:40.929]   - Field: 'local'
[17:29:40.929]   - Field: 'owner'
[17:29:40.929]   - Field: 'envir'
[17:29:40.930]   - Field: 'packages'
[17:29:40.930]   - Field: 'gc'
[17:29:40.930]   - Field: 'conditions'
[17:29:40.930]   - Field: 'expr'
[17:29:40.931]   - Field: 'uuid'
[17:29:40.931]   - Field: 'seed'
[17:29:40.931]   - Field: 'version'
[17:29:40.932]   - Field: 'result'
[17:29:40.932]   - Field: 'asynchronous'
[17:29:40.932]   - Field: 'calls'
[17:29:40.933]   - Field: 'globals'
[17:29:40.933]   - Field: 'stdout'
[17:29:40.933]   - Field: 'earlySignal'
[17:29:40.934]   - Field: 'lazy'
[17:29:40.934]   - Field: 'state'
[17:29:40.934] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:40.935] - Launch lazy future ...
[17:29:40.935] Packages needed by the future expression (n = 0): <none>
[17:29:40.935] Packages needed by future strategies (n = 0): <none>
[17:29:40.936] {
[17:29:40.936]     {
[17:29:40.936]         {
[17:29:40.936]             ...future.startTime <- base::Sys.time()
[17:29:40.936]             {
[17:29:40.936]                 {
[17:29:40.936]                   {
[17:29:40.936]                     base::local({
[17:29:40.936]                       has_future <- base::requireNamespace("future", 
[17:29:40.936]                         quietly = TRUE)
[17:29:40.936]                       if (has_future) {
[17:29:40.936]                         ns <- base::getNamespace("future")
[17:29:40.936]                         version <- ns[[".package"]][["version"]]
[17:29:40.936]                         if (is.null(version)) 
[17:29:40.936]                           version <- utils::packageVersion("future")
[17:29:40.936]                       }
[17:29:40.936]                       else {
[17:29:40.936]                         version <- NULL
[17:29:40.936]                       }
[17:29:40.936]                       if (!has_future || version < "1.8.0") {
[17:29:40.936]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:40.936]                           "", base::R.version$version.string), 
[17:29:40.936]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:40.936]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:40.936]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:40.936]                             "release", "version")], collapse = " "), 
[17:29:40.936]                           hostname = base::Sys.info()[["nodename"]])
[17:29:40.936]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:40.936]                           info)
[17:29:40.936]                         info <- base::paste(info, collapse = "; ")
[17:29:40.936]                         if (!has_future) {
[17:29:40.936]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:40.936]                             info)
[17:29:40.936]                         }
[17:29:40.936]                         else {
[17:29:40.936]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:40.936]                             info, version)
[17:29:40.936]                         }
[17:29:40.936]                         base::stop(msg)
[17:29:40.936]                       }
[17:29:40.936]                     })
[17:29:40.936]                   }
[17:29:40.936]                   ...future.strategy.old <- future::plan("list")
[17:29:40.936]                   options(future.plan = NULL)
[17:29:40.936]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.936]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:40.936]                 }
[17:29:40.936]                 ...future.workdir <- getwd()
[17:29:40.936]             }
[17:29:40.936]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:40.936]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:40.936]         }
[17:29:40.936]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:40.936]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:40.936]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:40.936]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:40.936]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:40.936]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:40.936]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:40.936]             base::names(...future.oldOptions))
[17:29:40.936]     }
[17:29:40.936]     if (FALSE) {
[17:29:40.936]     }
[17:29:40.936]     else {
[17:29:40.936]         if (TRUE) {
[17:29:40.936]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:40.936]                 open = "w")
[17:29:40.936]         }
[17:29:40.936]         else {
[17:29:40.936]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:40.936]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:40.936]         }
[17:29:40.936]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:40.936]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:40.936]             base::sink(type = "output", split = FALSE)
[17:29:40.936]             base::close(...future.stdout)
[17:29:40.936]         }, add = TRUE)
[17:29:40.936]     }
[17:29:40.936]     ...future.frame <- base::sys.nframe()
[17:29:40.936]     ...future.conditions <- base::list()
[17:29:40.936]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:40.936]     if (FALSE) {
[17:29:40.936]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:40.936]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:40.936]     }
[17:29:40.936]     ...future.result <- base::tryCatch({
[17:29:40.936]         base::withCallingHandlers({
[17:29:40.936]             ...future.value <- base::withVisible(base::local({
[17:29:40.936]                 sample(x, size = 1L)
[17:29:40.936]             }))
[17:29:40.936]             future::FutureResult(value = ...future.value$value, 
[17:29:40.936]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.936]                   ...future.rng), globalenv = if (FALSE) 
[17:29:40.936]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:40.936]                     ...future.globalenv.names))
[17:29:40.936]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:40.936]         }, condition = base::local({
[17:29:40.936]             c <- base::c
[17:29:40.936]             inherits <- base::inherits
[17:29:40.936]             invokeRestart <- base::invokeRestart
[17:29:40.936]             length <- base::length
[17:29:40.936]             list <- base::list
[17:29:40.936]             seq.int <- base::seq.int
[17:29:40.936]             signalCondition <- base::signalCondition
[17:29:40.936]             sys.calls <- base::sys.calls
[17:29:40.936]             `[[` <- base::`[[`
[17:29:40.936]             `+` <- base::`+`
[17:29:40.936]             `<<-` <- base::`<<-`
[17:29:40.936]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:40.936]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:40.936]                   3L)]
[17:29:40.936]             }
[17:29:40.936]             function(cond) {
[17:29:40.936]                 is_error <- inherits(cond, "error")
[17:29:40.936]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:40.936]                   NULL)
[17:29:40.936]                 if (is_error) {
[17:29:40.936]                   sessionInformation <- function() {
[17:29:40.936]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:40.936]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:40.936]                       search = base::search(), system = base::Sys.info())
[17:29:40.936]                   }
[17:29:40.936]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.936]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:40.936]                     cond$call), session = sessionInformation(), 
[17:29:40.936]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:40.936]                   signalCondition(cond)
[17:29:40.936]                 }
[17:29:40.936]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:40.936]                 "immediateCondition"))) {
[17:29:40.936]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:40.936]                   ...future.conditions[[length(...future.conditions) + 
[17:29:40.936]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:40.936]                   if (TRUE && !signal) {
[17:29:40.936]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.936]                     {
[17:29:40.936]                       inherits <- base::inherits
[17:29:40.936]                       invokeRestart <- base::invokeRestart
[17:29:40.936]                       is.null <- base::is.null
[17:29:40.936]                       muffled <- FALSE
[17:29:40.936]                       if (inherits(cond, "message")) {
[17:29:40.936]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.936]                         if (muffled) 
[17:29:40.936]                           invokeRestart("muffleMessage")
[17:29:40.936]                       }
[17:29:40.936]                       else if (inherits(cond, "warning")) {
[17:29:40.936]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.936]                         if (muffled) 
[17:29:40.936]                           invokeRestart("muffleWarning")
[17:29:40.936]                       }
[17:29:40.936]                       else if (inherits(cond, "condition")) {
[17:29:40.936]                         if (!is.null(pattern)) {
[17:29:40.936]                           computeRestarts <- base::computeRestarts
[17:29:40.936]                           grepl <- base::grepl
[17:29:40.936]                           restarts <- computeRestarts(cond)
[17:29:40.936]                           for (restart in restarts) {
[17:29:40.936]                             name <- restart$name
[17:29:40.936]                             if (is.null(name)) 
[17:29:40.936]                               next
[17:29:40.936]                             if (!grepl(pattern, name)) 
[17:29:40.936]                               next
[17:29:40.936]                             invokeRestart(restart)
[17:29:40.936]                             muffled <- TRUE
[17:29:40.936]                             break
[17:29:40.936]                           }
[17:29:40.936]                         }
[17:29:40.936]                       }
[17:29:40.936]                       invisible(muffled)
[17:29:40.936]                     }
[17:29:40.936]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.936]                   }
[17:29:40.936]                 }
[17:29:40.936]                 else {
[17:29:40.936]                   if (TRUE) {
[17:29:40.936]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:40.936]                     {
[17:29:40.936]                       inherits <- base::inherits
[17:29:40.936]                       invokeRestart <- base::invokeRestart
[17:29:40.936]                       is.null <- base::is.null
[17:29:40.936]                       muffled <- FALSE
[17:29:40.936]                       if (inherits(cond, "message")) {
[17:29:40.936]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:40.936]                         if (muffled) 
[17:29:40.936]                           invokeRestart("muffleMessage")
[17:29:40.936]                       }
[17:29:40.936]                       else if (inherits(cond, "warning")) {
[17:29:40.936]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:40.936]                         if (muffled) 
[17:29:40.936]                           invokeRestart("muffleWarning")
[17:29:40.936]                       }
[17:29:40.936]                       else if (inherits(cond, "condition")) {
[17:29:40.936]                         if (!is.null(pattern)) {
[17:29:40.936]                           computeRestarts <- base::computeRestarts
[17:29:40.936]                           grepl <- base::grepl
[17:29:40.936]                           restarts <- computeRestarts(cond)
[17:29:40.936]                           for (restart in restarts) {
[17:29:40.936]                             name <- restart$name
[17:29:40.936]                             if (is.null(name)) 
[17:29:40.936]                               next
[17:29:40.936]                             if (!grepl(pattern, name)) 
[17:29:40.936]                               next
[17:29:40.936]                             invokeRestart(restart)
[17:29:40.936]                             muffled <- TRUE
[17:29:40.936]                             break
[17:29:40.936]                           }
[17:29:40.936]                         }
[17:29:40.936]                       }
[17:29:40.936]                       invisible(muffled)
[17:29:40.936]                     }
[17:29:40.936]                     muffleCondition(cond, pattern = "^muffle")
[17:29:40.936]                   }
[17:29:40.936]                 }
[17:29:40.936]             }
[17:29:40.936]         }))
[17:29:40.936]     }, error = function(ex) {
[17:29:40.936]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:40.936]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:40.936]                 ...future.rng), started = ...future.startTime, 
[17:29:40.936]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:40.936]             version = "1.8"), class = "FutureResult")
[17:29:40.936]     }, finally = {
[17:29:40.936]         if (!identical(...future.workdir, getwd())) 
[17:29:40.936]             setwd(...future.workdir)
[17:29:40.936]         {
[17:29:40.936]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:40.936]                 ...future.oldOptions$nwarnings <- NULL
[17:29:40.936]             }
[17:29:40.936]             base::options(...future.oldOptions)
[17:29:40.936]             if (.Platform$OS.type == "windows") {
[17:29:40.936]                 old_names <- names(...future.oldEnvVars)
[17:29:40.936]                 envs <- base::Sys.getenv()
[17:29:40.936]                 names <- names(envs)
[17:29:40.936]                 common <- intersect(names, old_names)
[17:29:40.936]                 added <- setdiff(names, old_names)
[17:29:40.936]                 removed <- setdiff(old_names, names)
[17:29:40.936]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:40.936]                   envs[common]]
[17:29:40.936]                 NAMES <- toupper(changed)
[17:29:40.936]                 args <- list()
[17:29:40.936]                 for (kk in seq_along(NAMES)) {
[17:29:40.936]                   name <- changed[[kk]]
[17:29:40.936]                   NAME <- NAMES[[kk]]
[17:29:40.936]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.936]                     next
[17:29:40.936]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.936]                 }
[17:29:40.936]                 NAMES <- toupper(added)
[17:29:40.936]                 for (kk in seq_along(NAMES)) {
[17:29:40.936]                   name <- added[[kk]]
[17:29:40.936]                   NAME <- NAMES[[kk]]
[17:29:40.936]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.936]                     next
[17:29:40.936]                   args[[name]] <- ""
[17:29:40.936]                 }
[17:29:40.936]                 NAMES <- toupper(removed)
[17:29:40.936]                 for (kk in seq_along(NAMES)) {
[17:29:40.936]                   name <- removed[[kk]]
[17:29:40.936]                   NAME <- NAMES[[kk]]
[17:29:40.936]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:40.936]                     next
[17:29:40.936]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:40.936]                 }
[17:29:40.936]                 if (length(args) > 0) 
[17:29:40.936]                   base::do.call(base::Sys.setenv, args = args)
[17:29:40.936]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:40.936]             }
[17:29:40.936]             else {
[17:29:40.936]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:40.936]             }
[17:29:40.936]             {
[17:29:40.936]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:40.936]                   0L) {
[17:29:40.936]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:40.936]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:40.936]                   base::options(opts)
[17:29:40.936]                 }
[17:29:40.936]                 {
[17:29:40.936]                   {
[17:29:40.936]                     base::assign(".Random.seed", c(10407L, 604992664L, 
[17:29:40.936]                     -1930727367L, -1517772855L, 1574614759L, 
[17:29:40.936]                     140996430L, 369472255L), envir = base::globalenv(), 
[17:29:40.936]                       inherits = FALSE)
[17:29:40.936]                     NULL
[17:29:40.936]                   }
[17:29:40.936]                   options(future.plan = NULL)
[17:29:40.936]                   if (is.na(NA_character_)) 
[17:29:40.936]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:40.936]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:40.936]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:40.936]                     .init = FALSE)
[17:29:40.936]                 }
[17:29:40.936]             }
[17:29:40.936]         }
[17:29:40.936]     })
[17:29:40.936]     if (TRUE) {
[17:29:40.936]         base::sink(type = "output", split = FALSE)
[17:29:40.936]         if (TRUE) {
[17:29:40.936]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:40.936]         }
[17:29:40.936]         else {
[17:29:40.936]             ...future.result["stdout"] <- base::list(NULL)
[17:29:40.936]         }
[17:29:40.936]         base::close(...future.stdout)
[17:29:40.936]         ...future.stdout <- NULL
[17:29:40.936]     }
[17:29:40.936]     ...future.result$conditions <- ...future.conditions
[17:29:40.936]     ...future.result$finished <- base::Sys.time()
[17:29:40.936]     ...future.result
[17:29:40.936] }
[17:29:40.943] assign_globals() ...
[17:29:40.943] List of 1
[17:29:40.943]  $ x: int [1:4] 0 1 2 3
[17:29:40.943]  - attr(*, "where")=List of 1
[17:29:40.943]   ..$ x:<environment: R_EmptyEnv> 
[17:29:40.943]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:40.943]  - attr(*, "resolved")= logi FALSE
[17:29:40.943]  - attr(*, "total_size")= int 133
[17:29:40.943]  - attr(*, "already-done")= logi TRUE
[17:29:40.946] - copied 'x' to environment
[17:29:40.947] assign_globals() ... done
[17:29:40.947] plan(): Setting new future strategy stack:
[17:29:40.947] List of future strategies:
[17:29:40.947] 1. sequential:
[17:29:40.947]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.947]    - tweaked: FALSE
[17:29:40.947]    - call: NULL
[17:29:40.948] plan(): nbrOfWorkers() = 1
[17:29:40.950] plan(): Setting new future strategy stack:
[17:29:40.950] List of future strategies:
[17:29:40.950] 1. sequential:
[17:29:40.950]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:40.950]    - tweaked: FALSE
[17:29:40.950]    - call: plan(strategy)
[17:29:40.951] plan(): nbrOfWorkers() = 1
[17:29:40.951] SequentialFuture started (and completed)
[17:29:40.951] - Launch lazy future ... done
[17:29:40.951] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_4-298883'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add7c6c028
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.953] resolve() on list ...
[17:29:40.953]  recursive: 0
[17:29:40.953]  length: 4
[17:29:40.953] 
[17:29:40.953] resolved() for 'SequentialFuture' ...
[17:29:40.954] - state: 'finished'
[17:29:40.954] - run: TRUE
[17:29:40.954] - result: 'FutureResult'
[17:29:40.954] resolved() for 'SequentialFuture' ... done
[17:29:40.954] Future #1
[17:29:40.955] signalConditionsASAP(SequentialFuture, pos=1) ...
[17:29:40.955] - nx: 4
[17:29:40.955] - relay: TRUE
[17:29:40.955] - stdout: TRUE
[17:29:40.955] - signal: TRUE
[17:29:40.955] - resignal: FALSE
[17:29:40.955] - force: TRUE
[17:29:40.956] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:40.956] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:40.956]  - until=1
[17:29:40.956]  - relaying element #1
[17:29:40.957] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:40.957] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:40.957] signalConditionsASAP(SequentialFuture, pos=1) ... done
[17:29:40.958]  length: 3 (resolved future 1)
[17:29:40.958] resolved() for 'SequentialFuture' ...
[17:29:40.958] - state: 'finished'
[17:29:40.959] - run: TRUE
[17:29:40.959] - result: 'FutureResult'
[17:29:40.959] resolved() for 'SequentialFuture' ... done
[17:29:40.960] Future #2
[17:29:40.960] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:29:40.960] - nx: 4
[17:29:40.961] - relay: TRUE
[17:29:40.961] - stdout: TRUE
[17:29:40.961] - signal: TRUE
[17:29:40.961] - resignal: FALSE
[17:29:40.962] - force: TRUE
[17:29:40.962] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:40.962] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:40.963]  - until=2
[17:29:40.963]  - relaying element #2
[17:29:40.963] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:40.964] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:40.964] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:29:40.964]  length: 2 (resolved future 2)
[17:29:40.965] resolved() for 'SequentialFuture' ...
[17:29:40.965] - state: 'finished'
[17:29:40.965] - run: TRUE
[17:29:40.966] - result: 'FutureResult'
[17:29:40.969] resolved() for 'SequentialFuture' ... done
[17:29:40.969] Future #3
[17:29:40.970] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:29:40.970] - nx: 4
[17:29:40.970] - relay: TRUE
[17:29:40.970] - stdout: TRUE
[17:29:40.971] - signal: TRUE
[17:29:40.971] - resignal: FALSE
[17:29:40.971] - force: TRUE
[17:29:40.971] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:40.972] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:40.972]  - until=3
[17:29:40.972]  - relaying element #3
[17:29:40.973] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:40.973] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:40.974] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:29:40.974]  length: 1 (resolved future 3)
[17:29:40.974] resolved() for 'SequentialFuture' ...
[17:29:40.975] - state: 'finished'
[17:29:40.975] - run: TRUE
[17:29:40.975] - result: 'FutureResult'
[17:29:40.976] resolved() for 'SequentialFuture' ... done
[17:29:40.976] Future #4
[17:29:40.977] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:29:40.977] - nx: 4
[17:29:40.977] - relay: TRUE
[17:29:40.977] - stdout: TRUE
[17:29:40.978] - signal: TRUE
[17:29:40.978] - resignal: FALSE
[17:29:40.978] - force: TRUE
[17:29:40.978] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:40.979] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:40.979]  - until=4
[17:29:40.979]  - relaying element #4
[17:29:40.980] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.980] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.980] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:29:40.981]  length: 0 (resolved future 4)
[17:29:40.981] Relaying remaining futures
[17:29:40.981] signalConditionsASAP(NULL, pos=0) ...
[17:29:40.982] - nx: 4
[17:29:40.982] - relay: TRUE
[17:29:40.982] - stdout: TRUE
[17:29:40.983] - signal: TRUE
[17:29:40.983] - resignal: FALSE
[17:29:40.983] - force: TRUE
[17:29:40.983] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.984] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:29:40.984] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.984] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:40.985] signalConditionsASAP(NULL, pos=0) ... done
[17:29:40.985] resolve() on list ... DONE
[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 0

[[4]]
[1] 3

[17:29:40.986] getGlobalsAndPackages() ...
[17:29:40.986] Searching for globals...
[17:29:40.989] - globals found: [3] '{', 'sample', 'x'
[17:29:40.989] Searching for globals ... DONE
[17:29:40.989] Resolving globals: FALSE
[17:29:40.990] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:40.991] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:40.991] - globals: [1] 'x'
[17:29:40.992] 
[17:29:40.992] getGlobalsAndPackages() ... DONE
[17:29:40.993] run() for 'Future' ...
[17:29:40.993] - state: 'created'
[17:29:40.993] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:40.994] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:40.994] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:40.995]   - Field: 'label'
[17:29:40.995]   - Field: 'local'
[17:29:40.995]   - Field: 'owner'
[17:29:40.996]   - Field: 'envir'
[17:29:40.996]   - Field: 'packages'
[17:29:40.996]   - Field: 'gc'
[17:29:40.997]   - Field: 'conditions'
[17:29:40.997]   - Field: 'expr'
[17:29:40.997]   - Field: 'uuid'
[17:29:40.998]   - Field: 'seed'
[17:29:40.998]   - Field: 'version'
[17:29:40.998]   - Field: 'result'
[17:29:40.999]   - Field: 'asynchronous'
[17:29:40.999]   - Field: 'calls'
[17:29:40.999]   - Field: 'globals'
[17:29:41.000]   - Field: 'stdout'
[17:29:41.000]   - Field: 'earlySignal'
[17:29:41.000]   - Field: 'lazy'
[17:29:41.001]   - Field: 'state'
[17:29:41.001] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.001] - Launch lazy future ...
[17:29:41.002] Packages needed by the future expression (n = 0): <none>
[17:29:41.002] Packages needed by future strategies (n = 0): <none>
[17:29:41.003] {
[17:29:41.003]     {
[17:29:41.003]         {
[17:29:41.003]             ...future.startTime <- base::Sys.time()
[17:29:41.003]             {
[17:29:41.003]                 {
[17:29:41.003]                   {
[17:29:41.003]                     base::local({
[17:29:41.003]                       has_future <- base::requireNamespace("future", 
[17:29:41.003]                         quietly = TRUE)
[17:29:41.003]                       if (has_future) {
[17:29:41.003]                         ns <- base::getNamespace("future")
[17:29:41.003]                         version <- ns[[".package"]][["version"]]
[17:29:41.003]                         if (is.null(version)) 
[17:29:41.003]                           version <- utils::packageVersion("future")
[17:29:41.003]                       }
[17:29:41.003]                       else {
[17:29:41.003]                         version <- NULL
[17:29:41.003]                       }
[17:29:41.003]                       if (!has_future || version < "1.8.0") {
[17:29:41.003]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.003]                           "", base::R.version$version.string), 
[17:29:41.003]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.003]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.003]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.003]                             "release", "version")], collapse = " "), 
[17:29:41.003]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.003]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.003]                           info)
[17:29:41.003]                         info <- base::paste(info, collapse = "; ")
[17:29:41.003]                         if (!has_future) {
[17:29:41.003]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.003]                             info)
[17:29:41.003]                         }
[17:29:41.003]                         else {
[17:29:41.003]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.003]                             info, version)
[17:29:41.003]                         }
[17:29:41.003]                         base::stop(msg)
[17:29:41.003]                       }
[17:29:41.003]                     })
[17:29:41.003]                   }
[17:29:41.003]                   ...future.strategy.old <- future::plan("list")
[17:29:41.003]                   options(future.plan = NULL)
[17:29:41.003]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.003]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.003]                 }
[17:29:41.003]                 ...future.workdir <- getwd()
[17:29:41.003]             }
[17:29:41.003]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.003]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.003]         }
[17:29:41.003]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.003]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.003]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.003]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.003]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.003]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.003]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.003]             base::names(...future.oldOptions))
[17:29:41.003]     }
[17:29:41.003]     if (FALSE) {
[17:29:41.003]     }
[17:29:41.003]     else {
[17:29:41.003]         if (TRUE) {
[17:29:41.003]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.003]                 open = "w")
[17:29:41.003]         }
[17:29:41.003]         else {
[17:29:41.003]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.003]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.003]         }
[17:29:41.003]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.003]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.003]             base::sink(type = "output", split = FALSE)
[17:29:41.003]             base::close(...future.stdout)
[17:29:41.003]         }, add = TRUE)
[17:29:41.003]     }
[17:29:41.003]     ...future.frame <- base::sys.nframe()
[17:29:41.003]     ...future.conditions <- base::list()
[17:29:41.003]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.003]     if (FALSE) {
[17:29:41.003]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.003]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.003]     }
[17:29:41.003]     ...future.result <- base::tryCatch({
[17:29:41.003]         base::withCallingHandlers({
[17:29:41.003]             ...future.value <- base::withVisible(base::local({
[17:29:41.003]                 sample(x, size = 1L)
[17:29:41.003]             }))
[17:29:41.003]             future::FutureResult(value = ...future.value$value, 
[17:29:41.003]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.003]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.003]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.003]                     ...future.globalenv.names))
[17:29:41.003]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.003]         }, condition = base::local({
[17:29:41.003]             c <- base::c
[17:29:41.003]             inherits <- base::inherits
[17:29:41.003]             invokeRestart <- base::invokeRestart
[17:29:41.003]             length <- base::length
[17:29:41.003]             list <- base::list
[17:29:41.003]             seq.int <- base::seq.int
[17:29:41.003]             signalCondition <- base::signalCondition
[17:29:41.003]             sys.calls <- base::sys.calls
[17:29:41.003]             `[[` <- base::`[[`
[17:29:41.003]             `+` <- base::`+`
[17:29:41.003]             `<<-` <- base::`<<-`
[17:29:41.003]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.003]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.003]                   3L)]
[17:29:41.003]             }
[17:29:41.003]             function(cond) {
[17:29:41.003]                 is_error <- inherits(cond, "error")
[17:29:41.003]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.003]                   NULL)
[17:29:41.003]                 if (is_error) {
[17:29:41.003]                   sessionInformation <- function() {
[17:29:41.003]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.003]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.003]                       search = base::search(), system = base::Sys.info())
[17:29:41.003]                   }
[17:29:41.003]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.003]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.003]                     cond$call), session = sessionInformation(), 
[17:29:41.003]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.003]                   signalCondition(cond)
[17:29:41.003]                 }
[17:29:41.003]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.003]                 "immediateCondition"))) {
[17:29:41.003]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.003]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.003]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.003]                   if (TRUE && !signal) {
[17:29:41.003]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.003]                     {
[17:29:41.003]                       inherits <- base::inherits
[17:29:41.003]                       invokeRestart <- base::invokeRestart
[17:29:41.003]                       is.null <- base::is.null
[17:29:41.003]                       muffled <- FALSE
[17:29:41.003]                       if (inherits(cond, "message")) {
[17:29:41.003]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.003]                         if (muffled) 
[17:29:41.003]                           invokeRestart("muffleMessage")
[17:29:41.003]                       }
[17:29:41.003]                       else if (inherits(cond, "warning")) {
[17:29:41.003]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.003]                         if (muffled) 
[17:29:41.003]                           invokeRestart("muffleWarning")
[17:29:41.003]                       }
[17:29:41.003]                       else if (inherits(cond, "condition")) {
[17:29:41.003]                         if (!is.null(pattern)) {
[17:29:41.003]                           computeRestarts <- base::computeRestarts
[17:29:41.003]                           grepl <- base::grepl
[17:29:41.003]                           restarts <- computeRestarts(cond)
[17:29:41.003]                           for (restart in restarts) {
[17:29:41.003]                             name <- restart$name
[17:29:41.003]                             if (is.null(name)) 
[17:29:41.003]                               next
[17:29:41.003]                             if (!grepl(pattern, name)) 
[17:29:41.003]                               next
[17:29:41.003]                             invokeRestart(restart)
[17:29:41.003]                             muffled <- TRUE
[17:29:41.003]                             break
[17:29:41.003]                           }
[17:29:41.003]                         }
[17:29:41.003]                       }
[17:29:41.003]                       invisible(muffled)
[17:29:41.003]                     }
[17:29:41.003]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.003]                   }
[17:29:41.003]                 }
[17:29:41.003]                 else {
[17:29:41.003]                   if (TRUE) {
[17:29:41.003]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.003]                     {
[17:29:41.003]                       inherits <- base::inherits
[17:29:41.003]                       invokeRestart <- base::invokeRestart
[17:29:41.003]                       is.null <- base::is.null
[17:29:41.003]                       muffled <- FALSE
[17:29:41.003]                       if (inherits(cond, "message")) {
[17:29:41.003]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.003]                         if (muffled) 
[17:29:41.003]                           invokeRestart("muffleMessage")
[17:29:41.003]                       }
[17:29:41.003]                       else if (inherits(cond, "warning")) {
[17:29:41.003]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.003]                         if (muffled) 
[17:29:41.003]                           invokeRestart("muffleWarning")
[17:29:41.003]                       }
[17:29:41.003]                       else if (inherits(cond, "condition")) {
[17:29:41.003]                         if (!is.null(pattern)) {
[17:29:41.003]                           computeRestarts <- base::computeRestarts
[17:29:41.003]                           grepl <- base::grepl
[17:29:41.003]                           restarts <- computeRestarts(cond)
[17:29:41.003]                           for (restart in restarts) {
[17:29:41.003]                             name <- restart$name
[17:29:41.003]                             if (is.null(name)) 
[17:29:41.003]                               next
[17:29:41.003]                             if (!grepl(pattern, name)) 
[17:29:41.003]                               next
[17:29:41.003]                             invokeRestart(restart)
[17:29:41.003]                             muffled <- TRUE
[17:29:41.003]                             break
[17:29:41.003]                           }
[17:29:41.003]                         }
[17:29:41.003]                       }
[17:29:41.003]                       invisible(muffled)
[17:29:41.003]                     }
[17:29:41.003]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.003]                   }
[17:29:41.003]                 }
[17:29:41.003]             }
[17:29:41.003]         }))
[17:29:41.003]     }, error = function(ex) {
[17:29:41.003]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.003]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.003]                 ...future.rng), started = ...future.startTime, 
[17:29:41.003]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.003]             version = "1.8"), class = "FutureResult")
[17:29:41.003]     }, finally = {
[17:29:41.003]         if (!identical(...future.workdir, getwd())) 
[17:29:41.003]             setwd(...future.workdir)
[17:29:41.003]         {
[17:29:41.003]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.003]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.003]             }
[17:29:41.003]             base::options(...future.oldOptions)
[17:29:41.003]             if (.Platform$OS.type == "windows") {
[17:29:41.003]                 old_names <- names(...future.oldEnvVars)
[17:29:41.003]                 envs <- base::Sys.getenv()
[17:29:41.003]                 names <- names(envs)
[17:29:41.003]                 common <- intersect(names, old_names)
[17:29:41.003]                 added <- setdiff(names, old_names)
[17:29:41.003]                 removed <- setdiff(old_names, names)
[17:29:41.003]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.003]                   envs[common]]
[17:29:41.003]                 NAMES <- toupper(changed)
[17:29:41.003]                 args <- list()
[17:29:41.003]                 for (kk in seq_along(NAMES)) {
[17:29:41.003]                   name <- changed[[kk]]
[17:29:41.003]                   NAME <- NAMES[[kk]]
[17:29:41.003]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.003]                     next
[17:29:41.003]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.003]                 }
[17:29:41.003]                 NAMES <- toupper(added)
[17:29:41.003]                 for (kk in seq_along(NAMES)) {
[17:29:41.003]                   name <- added[[kk]]
[17:29:41.003]                   NAME <- NAMES[[kk]]
[17:29:41.003]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.003]                     next
[17:29:41.003]                   args[[name]] <- ""
[17:29:41.003]                 }
[17:29:41.003]                 NAMES <- toupper(removed)
[17:29:41.003]                 for (kk in seq_along(NAMES)) {
[17:29:41.003]                   name <- removed[[kk]]
[17:29:41.003]                   NAME <- NAMES[[kk]]
[17:29:41.003]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.003]                     next
[17:29:41.003]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.003]                 }
[17:29:41.003]                 if (length(args) > 0) 
[17:29:41.003]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.003]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.003]             }
[17:29:41.003]             else {
[17:29:41.003]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.003]             }
[17:29:41.003]             {
[17:29:41.003]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.003]                   0L) {
[17:29:41.003]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.003]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.003]                   base::options(opts)
[17:29:41.003]                 }
[17:29:41.003]                 {
[17:29:41.003]                   {
[17:29:41.003]                     base::assign(".Random.seed", c(10407L, -154415262L, 
[17:29:41.003]                     461427532L, -1907126193L, 344757889L, 1497903237L, 
[17:29:41.003]                     226026504L), envir = base::globalenv(), inherits = FALSE)
[17:29:41.003]                     NULL
[17:29:41.003]                   }
[17:29:41.003]                   options(future.plan = NULL)
[17:29:41.003]                   if (is.na(NA_character_)) 
[17:29:41.003]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.003]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.003]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.003]                     .init = FALSE)
[17:29:41.003]                 }
[17:29:41.003]             }
[17:29:41.003]         }
[17:29:41.003]     })
[17:29:41.003]     if (TRUE) {
[17:29:41.003]         base::sink(type = "output", split = FALSE)
[17:29:41.003]         if (TRUE) {
[17:29:41.003]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.003]         }
[17:29:41.003]         else {
[17:29:41.003]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.003]         }
[17:29:41.003]         base::close(...future.stdout)
[17:29:41.003]         ...future.stdout <- NULL
[17:29:41.003]     }
[17:29:41.003]     ...future.result$conditions <- ...future.conditions
[17:29:41.003]     ...future.result$finished <- base::Sys.time()
[17:29:41.003]     ...future.result
[17:29:41.003] }
[17:29:41.009] assign_globals() ...
[17:29:41.009] List of 1
[17:29:41.009]  $ x: int [1:4] 0 1 2 3
[17:29:41.009]  - attr(*, "where")=List of 1
[17:29:41.009]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.009]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.009]  - attr(*, "resolved")= logi FALSE
[17:29:41.009]  - attr(*, "total_size")= int 133
[17:29:41.009]  - attr(*, "already-done")= logi TRUE
[17:29:41.014] - copied 'x' to environment
[17:29:41.015] assign_globals() ... done
[17:29:41.015] plan(): Setting new future strategy stack:
[17:29:41.016] List of future strategies:
[17:29:41.016] 1. sequential:
[17:29:41.016]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.016]    - tweaked: FALSE
[17:29:41.016]    - call: NULL
[17:29:41.017] plan(): nbrOfWorkers() = 1
[17:29:41.019] plan(): Setting new future strategy stack:
[17:29:41.022] List of future strategies:
[17:29:41.022] 1. sequential:
[17:29:41.022]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.022]    - tweaked: FALSE
[17:29:41.022]    - call: plan(strategy)
[17:29:41.023] plan(): nbrOfWorkers() = 1
[17:29:41.023] SequentialFuture started (and completed)
[17:29:41.024] - Launch lazy future ... done
[17:29:41.024] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_1-557275'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add5f5f1b8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.026] getGlobalsAndPackages() ...
[17:29:41.026] Searching for globals...
[17:29:41.028] - globals found: [3] '{', 'sample', 'x'
[17:29:41.029] Searching for globals ... DONE
[17:29:41.029] Resolving globals: FALSE
[17:29:41.030] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.031] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.031] - globals: [1] 'x'
[17:29:41.031] 
[17:29:41.032] getGlobalsAndPackages() ... DONE
[17:29:41.032] run() for 'Future' ...
[17:29:41.032] - state: 'created'
[17:29:41.033] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.034] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.034] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.034]   - Field: 'label'
[17:29:41.035]   - Field: 'local'
[17:29:41.035]   - Field: 'owner'
[17:29:41.035]   - Field: 'envir'
[17:29:41.036]   - Field: 'packages'
[17:29:41.036]   - Field: 'gc'
[17:29:41.036]   - Field: 'conditions'
[17:29:41.036]   - Field: 'expr'
[17:29:41.037]   - Field: 'uuid'
[17:29:41.037]   - Field: 'seed'
[17:29:41.037]   - Field: 'version'
[17:29:41.038]   - Field: 'result'
[17:29:41.038]   - Field: 'asynchronous'
[17:29:41.038]   - Field: 'calls'
[17:29:41.038]   - Field: 'globals'
[17:29:41.039]   - Field: 'stdout'
[17:29:41.039]   - Field: 'earlySignal'
[17:29:41.039]   - Field: 'lazy'
[17:29:41.040]   - Field: 'state'
[17:29:41.040] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.040] - Launch lazy future ...
[17:29:41.041] Packages needed by the future expression (n = 0): <none>
[17:29:41.041] Packages needed by future strategies (n = 0): <none>
[17:29:41.042] {
[17:29:41.042]     {
[17:29:41.042]         {
[17:29:41.042]             ...future.startTime <- base::Sys.time()
[17:29:41.042]             {
[17:29:41.042]                 {
[17:29:41.042]                   {
[17:29:41.042]                     base::local({
[17:29:41.042]                       has_future <- base::requireNamespace("future", 
[17:29:41.042]                         quietly = TRUE)
[17:29:41.042]                       if (has_future) {
[17:29:41.042]                         ns <- base::getNamespace("future")
[17:29:41.042]                         version <- ns[[".package"]][["version"]]
[17:29:41.042]                         if (is.null(version)) 
[17:29:41.042]                           version <- utils::packageVersion("future")
[17:29:41.042]                       }
[17:29:41.042]                       else {
[17:29:41.042]                         version <- NULL
[17:29:41.042]                       }
[17:29:41.042]                       if (!has_future || version < "1.8.0") {
[17:29:41.042]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.042]                           "", base::R.version$version.string), 
[17:29:41.042]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.042]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.042]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.042]                             "release", "version")], collapse = " "), 
[17:29:41.042]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.042]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.042]                           info)
[17:29:41.042]                         info <- base::paste(info, collapse = "; ")
[17:29:41.042]                         if (!has_future) {
[17:29:41.042]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.042]                             info)
[17:29:41.042]                         }
[17:29:41.042]                         else {
[17:29:41.042]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.042]                             info, version)
[17:29:41.042]                         }
[17:29:41.042]                         base::stop(msg)
[17:29:41.042]                       }
[17:29:41.042]                     })
[17:29:41.042]                   }
[17:29:41.042]                   ...future.strategy.old <- future::plan("list")
[17:29:41.042]                   options(future.plan = NULL)
[17:29:41.042]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.042]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.042]                 }
[17:29:41.042]                 ...future.workdir <- getwd()
[17:29:41.042]             }
[17:29:41.042]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.042]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.042]         }
[17:29:41.042]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.042]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.042]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.042]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.042]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.042]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.042]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.042]             base::names(...future.oldOptions))
[17:29:41.042]     }
[17:29:41.042]     if (FALSE) {
[17:29:41.042]     }
[17:29:41.042]     else {
[17:29:41.042]         if (TRUE) {
[17:29:41.042]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.042]                 open = "w")
[17:29:41.042]         }
[17:29:41.042]         else {
[17:29:41.042]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.042]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.042]         }
[17:29:41.042]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.042]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.042]             base::sink(type = "output", split = FALSE)
[17:29:41.042]             base::close(...future.stdout)
[17:29:41.042]         }, add = TRUE)
[17:29:41.042]     }
[17:29:41.042]     ...future.frame <- base::sys.nframe()
[17:29:41.042]     ...future.conditions <- base::list()
[17:29:41.042]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.042]     if (FALSE) {
[17:29:41.042]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.042]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.042]     }
[17:29:41.042]     ...future.result <- base::tryCatch({
[17:29:41.042]         base::withCallingHandlers({
[17:29:41.042]             ...future.value <- base::withVisible(base::local({
[17:29:41.042]                 sample(x, size = 1L)
[17:29:41.042]             }))
[17:29:41.042]             future::FutureResult(value = ...future.value$value, 
[17:29:41.042]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.042]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.042]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.042]                     ...future.globalenv.names))
[17:29:41.042]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.042]         }, condition = base::local({
[17:29:41.042]             c <- base::c
[17:29:41.042]             inherits <- base::inherits
[17:29:41.042]             invokeRestart <- base::invokeRestart
[17:29:41.042]             length <- base::length
[17:29:41.042]             list <- base::list
[17:29:41.042]             seq.int <- base::seq.int
[17:29:41.042]             signalCondition <- base::signalCondition
[17:29:41.042]             sys.calls <- base::sys.calls
[17:29:41.042]             `[[` <- base::`[[`
[17:29:41.042]             `+` <- base::`+`
[17:29:41.042]             `<<-` <- base::`<<-`
[17:29:41.042]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.042]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.042]                   3L)]
[17:29:41.042]             }
[17:29:41.042]             function(cond) {
[17:29:41.042]                 is_error <- inherits(cond, "error")
[17:29:41.042]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.042]                   NULL)
[17:29:41.042]                 if (is_error) {
[17:29:41.042]                   sessionInformation <- function() {
[17:29:41.042]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.042]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.042]                       search = base::search(), system = base::Sys.info())
[17:29:41.042]                   }
[17:29:41.042]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.042]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.042]                     cond$call), session = sessionInformation(), 
[17:29:41.042]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.042]                   signalCondition(cond)
[17:29:41.042]                 }
[17:29:41.042]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.042]                 "immediateCondition"))) {
[17:29:41.042]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.042]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.042]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.042]                   if (TRUE && !signal) {
[17:29:41.042]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.042]                     {
[17:29:41.042]                       inherits <- base::inherits
[17:29:41.042]                       invokeRestart <- base::invokeRestart
[17:29:41.042]                       is.null <- base::is.null
[17:29:41.042]                       muffled <- FALSE
[17:29:41.042]                       if (inherits(cond, "message")) {
[17:29:41.042]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.042]                         if (muffled) 
[17:29:41.042]                           invokeRestart("muffleMessage")
[17:29:41.042]                       }
[17:29:41.042]                       else if (inherits(cond, "warning")) {
[17:29:41.042]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.042]                         if (muffled) 
[17:29:41.042]                           invokeRestart("muffleWarning")
[17:29:41.042]                       }
[17:29:41.042]                       else if (inherits(cond, "condition")) {
[17:29:41.042]                         if (!is.null(pattern)) {
[17:29:41.042]                           computeRestarts <- base::computeRestarts
[17:29:41.042]                           grepl <- base::grepl
[17:29:41.042]                           restarts <- computeRestarts(cond)
[17:29:41.042]                           for (restart in restarts) {
[17:29:41.042]                             name <- restart$name
[17:29:41.042]                             if (is.null(name)) 
[17:29:41.042]                               next
[17:29:41.042]                             if (!grepl(pattern, name)) 
[17:29:41.042]                               next
[17:29:41.042]                             invokeRestart(restart)
[17:29:41.042]                             muffled <- TRUE
[17:29:41.042]                             break
[17:29:41.042]                           }
[17:29:41.042]                         }
[17:29:41.042]                       }
[17:29:41.042]                       invisible(muffled)
[17:29:41.042]                     }
[17:29:41.042]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.042]                   }
[17:29:41.042]                 }
[17:29:41.042]                 else {
[17:29:41.042]                   if (TRUE) {
[17:29:41.042]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.042]                     {
[17:29:41.042]                       inherits <- base::inherits
[17:29:41.042]                       invokeRestart <- base::invokeRestart
[17:29:41.042]                       is.null <- base::is.null
[17:29:41.042]                       muffled <- FALSE
[17:29:41.042]                       if (inherits(cond, "message")) {
[17:29:41.042]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.042]                         if (muffled) 
[17:29:41.042]                           invokeRestart("muffleMessage")
[17:29:41.042]                       }
[17:29:41.042]                       else if (inherits(cond, "warning")) {
[17:29:41.042]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.042]                         if (muffled) 
[17:29:41.042]                           invokeRestart("muffleWarning")
[17:29:41.042]                       }
[17:29:41.042]                       else if (inherits(cond, "condition")) {
[17:29:41.042]                         if (!is.null(pattern)) {
[17:29:41.042]                           computeRestarts <- base::computeRestarts
[17:29:41.042]                           grepl <- base::grepl
[17:29:41.042]                           restarts <- computeRestarts(cond)
[17:29:41.042]                           for (restart in restarts) {
[17:29:41.042]                             name <- restart$name
[17:29:41.042]                             if (is.null(name)) 
[17:29:41.042]                               next
[17:29:41.042]                             if (!grepl(pattern, name)) 
[17:29:41.042]                               next
[17:29:41.042]                             invokeRestart(restart)
[17:29:41.042]                             muffled <- TRUE
[17:29:41.042]                             break
[17:29:41.042]                           }
[17:29:41.042]                         }
[17:29:41.042]                       }
[17:29:41.042]                       invisible(muffled)
[17:29:41.042]                     }
[17:29:41.042]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.042]                   }
[17:29:41.042]                 }
[17:29:41.042]             }
[17:29:41.042]         }))
[17:29:41.042]     }, error = function(ex) {
[17:29:41.042]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.042]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.042]                 ...future.rng), started = ...future.startTime, 
[17:29:41.042]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.042]             version = "1.8"), class = "FutureResult")
[17:29:41.042]     }, finally = {
[17:29:41.042]         if (!identical(...future.workdir, getwd())) 
[17:29:41.042]             setwd(...future.workdir)
[17:29:41.042]         {
[17:29:41.042]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.042]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.042]             }
[17:29:41.042]             base::options(...future.oldOptions)
[17:29:41.042]             if (.Platform$OS.type == "windows") {
[17:29:41.042]                 old_names <- names(...future.oldEnvVars)
[17:29:41.042]                 envs <- base::Sys.getenv()
[17:29:41.042]                 names <- names(envs)
[17:29:41.042]                 common <- intersect(names, old_names)
[17:29:41.042]                 added <- setdiff(names, old_names)
[17:29:41.042]                 removed <- setdiff(old_names, names)
[17:29:41.042]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.042]                   envs[common]]
[17:29:41.042]                 NAMES <- toupper(changed)
[17:29:41.042]                 args <- list()
[17:29:41.042]                 for (kk in seq_along(NAMES)) {
[17:29:41.042]                   name <- changed[[kk]]
[17:29:41.042]                   NAME <- NAMES[[kk]]
[17:29:41.042]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.042]                     next
[17:29:41.042]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.042]                 }
[17:29:41.042]                 NAMES <- toupper(added)
[17:29:41.042]                 for (kk in seq_along(NAMES)) {
[17:29:41.042]                   name <- added[[kk]]
[17:29:41.042]                   NAME <- NAMES[[kk]]
[17:29:41.042]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.042]                     next
[17:29:41.042]                   args[[name]] <- ""
[17:29:41.042]                 }
[17:29:41.042]                 NAMES <- toupper(removed)
[17:29:41.042]                 for (kk in seq_along(NAMES)) {
[17:29:41.042]                   name <- removed[[kk]]
[17:29:41.042]                   NAME <- NAMES[[kk]]
[17:29:41.042]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.042]                     next
[17:29:41.042]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.042]                 }
[17:29:41.042]                 if (length(args) > 0) 
[17:29:41.042]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.042]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.042]             }
[17:29:41.042]             else {
[17:29:41.042]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.042]             }
[17:29:41.042]             {
[17:29:41.042]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.042]                   0L) {
[17:29:41.042]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.042]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.042]                   base::options(opts)
[17:29:41.042]                 }
[17:29:41.042]                 {
[17:29:41.042]                   {
[17:29:41.042]                     base::assign(".Random.seed", c(10407L, -1907126193L, 
[17:29:41.042]                     -1610148932L, -598272471L, 226026504L, 695827463L, 
[17:29:41.042]                     -1122933629L), envir = base::globalenv(), 
[17:29:41.042]                       inherits = FALSE)
[17:29:41.042]                     NULL
[17:29:41.042]                   }
[17:29:41.042]                   options(future.plan = NULL)
[17:29:41.042]                   if (is.na(NA_character_)) 
[17:29:41.042]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.042]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.042]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.042]                     .init = FALSE)
[17:29:41.042]                 }
[17:29:41.042]             }
[17:29:41.042]         }
[17:29:41.042]     })
[17:29:41.042]     if (TRUE) {
[17:29:41.042]         base::sink(type = "output", split = FALSE)
[17:29:41.042]         if (TRUE) {
[17:29:41.042]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.042]         }
[17:29:41.042]         else {
[17:29:41.042]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.042]         }
[17:29:41.042]         base::close(...future.stdout)
[17:29:41.042]         ...future.stdout <- NULL
[17:29:41.042]     }
[17:29:41.042]     ...future.result$conditions <- ...future.conditions
[17:29:41.042]     ...future.result$finished <- base::Sys.time()
[17:29:41.042]     ...future.result
[17:29:41.042] }
[17:29:41.048] assign_globals() ...
[17:29:41.048] List of 1
[17:29:41.048]  $ x: int [1:4] 0 1 2 3
[17:29:41.048]  - attr(*, "where")=List of 1
[17:29:41.048]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.048]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.048]  - attr(*, "resolved")= logi FALSE
[17:29:41.048]  - attr(*, "total_size")= int 133
[17:29:41.048]  - attr(*, "already-done")= logi TRUE
[17:29:41.051] - copied 'x' to environment
[17:29:41.052] assign_globals() ... done
[17:29:41.052] plan(): Setting new future strategy stack:
[17:29:41.053] List of future strategies:
[17:29:41.053] 1. sequential:
[17:29:41.053]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.053]    - tweaked: FALSE
[17:29:41.053]    - call: NULL
[17:29:41.054] plan(): nbrOfWorkers() = 1
[17:29:41.056] plan(): Setting new future strategy stack:
[17:29:41.056] List of future strategies:
[17:29:41.056] 1. sequential:
[17:29:41.056]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.056]    - tweaked: FALSE
[17:29:41.056]    - call: plan(strategy)
[17:29:41.057] plan(): nbrOfWorkers() = 1
[17:29:41.058] SequentialFuture started (and completed)
[17:29:41.058] - Launch lazy future ... done
[17:29:41.058] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_2-859974'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add5f5f1b8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.060] getGlobalsAndPackages() ...
[17:29:41.060] Searching for globals...
[17:29:41.063] - globals found: [3] '{', 'sample', 'x'
[17:29:41.063] Searching for globals ... DONE
[17:29:41.063] Resolving globals: FALSE
[17:29:41.064] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.065] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.065] - globals: [1] 'x'
[17:29:41.065] 
[17:29:41.066] getGlobalsAndPackages() ... DONE
[17:29:41.066] run() for 'Future' ...
[17:29:41.067] - state: 'created'
[17:29:41.067] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.103] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.103] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.104]   - Field: 'label'
[17:29:41.104]   - Field: 'local'
[17:29:41.104]   - Field: 'owner'
[17:29:41.104]   - Field: 'envir'
[17:29:41.104]   - Field: 'packages'
[17:29:41.105]   - Field: 'gc'
[17:29:41.105]   - Field: 'conditions'
[17:29:41.105]   - Field: 'expr'
[17:29:41.105]   - Field: 'uuid'
[17:29:41.105]   - Field: 'seed'
[17:29:41.106]   - Field: 'version'
[17:29:41.106]   - Field: 'result'
[17:29:41.106]   - Field: 'asynchronous'
[17:29:41.106]   - Field: 'calls'
[17:29:41.106]   - Field: 'globals'
[17:29:41.107]   - Field: 'stdout'
[17:29:41.107]   - Field: 'earlySignal'
[17:29:41.107]   - Field: 'lazy'
[17:29:41.107]   - Field: 'state'
[17:29:41.107] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.107] - Launch lazy future ...
[17:29:41.108] Packages needed by the future expression (n = 0): <none>
[17:29:41.108] Packages needed by future strategies (n = 0): <none>
[17:29:41.109] {
[17:29:41.109]     {
[17:29:41.109]         {
[17:29:41.109]             ...future.startTime <- base::Sys.time()
[17:29:41.109]             {
[17:29:41.109]                 {
[17:29:41.109]                   {
[17:29:41.109]                     base::local({
[17:29:41.109]                       has_future <- base::requireNamespace("future", 
[17:29:41.109]                         quietly = TRUE)
[17:29:41.109]                       if (has_future) {
[17:29:41.109]                         ns <- base::getNamespace("future")
[17:29:41.109]                         version <- ns[[".package"]][["version"]]
[17:29:41.109]                         if (is.null(version)) 
[17:29:41.109]                           version <- utils::packageVersion("future")
[17:29:41.109]                       }
[17:29:41.109]                       else {
[17:29:41.109]                         version <- NULL
[17:29:41.109]                       }
[17:29:41.109]                       if (!has_future || version < "1.8.0") {
[17:29:41.109]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.109]                           "", base::R.version$version.string), 
[17:29:41.109]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.109]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.109]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.109]                             "release", "version")], collapse = " "), 
[17:29:41.109]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.109]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.109]                           info)
[17:29:41.109]                         info <- base::paste(info, collapse = "; ")
[17:29:41.109]                         if (!has_future) {
[17:29:41.109]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.109]                             info)
[17:29:41.109]                         }
[17:29:41.109]                         else {
[17:29:41.109]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.109]                             info, version)
[17:29:41.109]                         }
[17:29:41.109]                         base::stop(msg)
[17:29:41.109]                       }
[17:29:41.109]                     })
[17:29:41.109]                   }
[17:29:41.109]                   ...future.strategy.old <- future::plan("list")
[17:29:41.109]                   options(future.plan = NULL)
[17:29:41.109]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.109]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.109]                 }
[17:29:41.109]                 ...future.workdir <- getwd()
[17:29:41.109]             }
[17:29:41.109]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.109]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.109]         }
[17:29:41.109]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.109]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.109]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.109]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.109]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.109]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.109]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.109]             base::names(...future.oldOptions))
[17:29:41.109]     }
[17:29:41.109]     if (FALSE) {
[17:29:41.109]     }
[17:29:41.109]     else {
[17:29:41.109]         if (TRUE) {
[17:29:41.109]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.109]                 open = "w")
[17:29:41.109]         }
[17:29:41.109]         else {
[17:29:41.109]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.109]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.109]         }
[17:29:41.109]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.109]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.109]             base::sink(type = "output", split = FALSE)
[17:29:41.109]             base::close(...future.stdout)
[17:29:41.109]         }, add = TRUE)
[17:29:41.109]     }
[17:29:41.109]     ...future.frame <- base::sys.nframe()
[17:29:41.109]     ...future.conditions <- base::list()
[17:29:41.109]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.109]     if (FALSE) {
[17:29:41.109]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.109]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.109]     }
[17:29:41.109]     ...future.result <- base::tryCatch({
[17:29:41.109]         base::withCallingHandlers({
[17:29:41.109]             ...future.value <- base::withVisible(base::local({
[17:29:41.109]                 sample(x, size = 1L)
[17:29:41.109]             }))
[17:29:41.109]             future::FutureResult(value = ...future.value$value, 
[17:29:41.109]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.109]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.109]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.109]                     ...future.globalenv.names))
[17:29:41.109]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.109]         }, condition = base::local({
[17:29:41.109]             c <- base::c
[17:29:41.109]             inherits <- base::inherits
[17:29:41.109]             invokeRestart <- base::invokeRestart
[17:29:41.109]             length <- base::length
[17:29:41.109]             list <- base::list
[17:29:41.109]             seq.int <- base::seq.int
[17:29:41.109]             signalCondition <- base::signalCondition
[17:29:41.109]             sys.calls <- base::sys.calls
[17:29:41.109]             `[[` <- base::`[[`
[17:29:41.109]             `+` <- base::`+`
[17:29:41.109]             `<<-` <- base::`<<-`
[17:29:41.109]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.109]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.109]                   3L)]
[17:29:41.109]             }
[17:29:41.109]             function(cond) {
[17:29:41.109]                 is_error <- inherits(cond, "error")
[17:29:41.109]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.109]                   NULL)
[17:29:41.109]                 if (is_error) {
[17:29:41.109]                   sessionInformation <- function() {
[17:29:41.109]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.109]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.109]                       search = base::search(), system = base::Sys.info())
[17:29:41.109]                   }
[17:29:41.109]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.109]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.109]                     cond$call), session = sessionInformation(), 
[17:29:41.109]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.109]                   signalCondition(cond)
[17:29:41.109]                 }
[17:29:41.109]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.109]                 "immediateCondition"))) {
[17:29:41.109]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.109]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.109]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.109]                   if (TRUE && !signal) {
[17:29:41.109]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.109]                     {
[17:29:41.109]                       inherits <- base::inherits
[17:29:41.109]                       invokeRestart <- base::invokeRestart
[17:29:41.109]                       is.null <- base::is.null
[17:29:41.109]                       muffled <- FALSE
[17:29:41.109]                       if (inherits(cond, "message")) {
[17:29:41.109]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.109]                         if (muffled) 
[17:29:41.109]                           invokeRestart("muffleMessage")
[17:29:41.109]                       }
[17:29:41.109]                       else if (inherits(cond, "warning")) {
[17:29:41.109]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.109]                         if (muffled) 
[17:29:41.109]                           invokeRestart("muffleWarning")
[17:29:41.109]                       }
[17:29:41.109]                       else if (inherits(cond, "condition")) {
[17:29:41.109]                         if (!is.null(pattern)) {
[17:29:41.109]                           computeRestarts <- base::computeRestarts
[17:29:41.109]                           grepl <- base::grepl
[17:29:41.109]                           restarts <- computeRestarts(cond)
[17:29:41.109]                           for (restart in restarts) {
[17:29:41.109]                             name <- restart$name
[17:29:41.109]                             if (is.null(name)) 
[17:29:41.109]                               next
[17:29:41.109]                             if (!grepl(pattern, name)) 
[17:29:41.109]                               next
[17:29:41.109]                             invokeRestart(restart)
[17:29:41.109]                             muffled <- TRUE
[17:29:41.109]                             break
[17:29:41.109]                           }
[17:29:41.109]                         }
[17:29:41.109]                       }
[17:29:41.109]                       invisible(muffled)
[17:29:41.109]                     }
[17:29:41.109]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.109]                   }
[17:29:41.109]                 }
[17:29:41.109]                 else {
[17:29:41.109]                   if (TRUE) {
[17:29:41.109]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.109]                     {
[17:29:41.109]                       inherits <- base::inherits
[17:29:41.109]                       invokeRestart <- base::invokeRestart
[17:29:41.109]                       is.null <- base::is.null
[17:29:41.109]                       muffled <- FALSE
[17:29:41.109]                       if (inherits(cond, "message")) {
[17:29:41.109]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.109]                         if (muffled) 
[17:29:41.109]                           invokeRestart("muffleMessage")
[17:29:41.109]                       }
[17:29:41.109]                       else if (inherits(cond, "warning")) {
[17:29:41.109]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.109]                         if (muffled) 
[17:29:41.109]                           invokeRestart("muffleWarning")
[17:29:41.109]                       }
[17:29:41.109]                       else if (inherits(cond, "condition")) {
[17:29:41.109]                         if (!is.null(pattern)) {
[17:29:41.109]                           computeRestarts <- base::computeRestarts
[17:29:41.109]                           grepl <- base::grepl
[17:29:41.109]                           restarts <- computeRestarts(cond)
[17:29:41.109]                           for (restart in restarts) {
[17:29:41.109]                             name <- restart$name
[17:29:41.109]                             if (is.null(name)) 
[17:29:41.109]                               next
[17:29:41.109]                             if (!grepl(pattern, name)) 
[17:29:41.109]                               next
[17:29:41.109]                             invokeRestart(restart)
[17:29:41.109]                             muffled <- TRUE
[17:29:41.109]                             break
[17:29:41.109]                           }
[17:29:41.109]                         }
[17:29:41.109]                       }
[17:29:41.109]                       invisible(muffled)
[17:29:41.109]                     }
[17:29:41.109]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.109]                   }
[17:29:41.109]                 }
[17:29:41.109]             }
[17:29:41.109]         }))
[17:29:41.109]     }, error = function(ex) {
[17:29:41.109]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.109]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.109]                 ...future.rng), started = ...future.startTime, 
[17:29:41.109]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.109]             version = "1.8"), class = "FutureResult")
[17:29:41.109]     }, finally = {
[17:29:41.109]         if (!identical(...future.workdir, getwd())) 
[17:29:41.109]             setwd(...future.workdir)
[17:29:41.109]         {
[17:29:41.109]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.109]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.109]             }
[17:29:41.109]             base::options(...future.oldOptions)
[17:29:41.109]             if (.Platform$OS.type == "windows") {
[17:29:41.109]                 old_names <- names(...future.oldEnvVars)
[17:29:41.109]                 envs <- base::Sys.getenv()
[17:29:41.109]                 names <- names(envs)
[17:29:41.109]                 common <- intersect(names, old_names)
[17:29:41.109]                 added <- setdiff(names, old_names)
[17:29:41.109]                 removed <- setdiff(old_names, names)
[17:29:41.109]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.109]                   envs[common]]
[17:29:41.109]                 NAMES <- toupper(changed)
[17:29:41.109]                 args <- list()
[17:29:41.109]                 for (kk in seq_along(NAMES)) {
[17:29:41.109]                   name <- changed[[kk]]
[17:29:41.109]                   NAME <- NAMES[[kk]]
[17:29:41.109]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.109]                     next
[17:29:41.109]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.109]                 }
[17:29:41.109]                 NAMES <- toupper(added)
[17:29:41.109]                 for (kk in seq_along(NAMES)) {
[17:29:41.109]                   name <- added[[kk]]
[17:29:41.109]                   NAME <- NAMES[[kk]]
[17:29:41.109]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.109]                     next
[17:29:41.109]                   args[[name]] <- ""
[17:29:41.109]                 }
[17:29:41.109]                 NAMES <- toupper(removed)
[17:29:41.109]                 for (kk in seq_along(NAMES)) {
[17:29:41.109]                   name <- removed[[kk]]
[17:29:41.109]                   NAME <- NAMES[[kk]]
[17:29:41.109]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.109]                     next
[17:29:41.109]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.109]                 }
[17:29:41.109]                 if (length(args) > 0) 
[17:29:41.109]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.109]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.109]             }
[17:29:41.109]             else {
[17:29:41.109]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.109]             }
[17:29:41.109]             {
[17:29:41.109]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.109]                   0L) {
[17:29:41.109]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.109]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.109]                   base::options(opts)
[17:29:41.109]                 }
[17:29:41.109]                 {
[17:29:41.109]                   {
[17:29:41.109]                     base::assign(".Random.seed", c(10407L, -598272471L, 
[17:29:41.109]                     -1464914058L, 750895670L, -1122933629L, 1223536571L, 
[17:29:41.109]                     -100347073L), envir = base::globalenv(), 
[17:29:41.109]                       inherits = FALSE)
[17:29:41.109]                     NULL
[17:29:41.109]                   }
[17:29:41.109]                   options(future.plan = NULL)
[17:29:41.109]                   if (is.na(NA_character_)) 
[17:29:41.109]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.109]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.109]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.109]                     .init = FALSE)
[17:29:41.109]                 }
[17:29:41.109]             }
[17:29:41.109]         }
[17:29:41.109]     })
[17:29:41.109]     if (TRUE) {
[17:29:41.109]         base::sink(type = "output", split = FALSE)
[17:29:41.109]         if (TRUE) {
[17:29:41.109]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.109]         }
[17:29:41.109]         else {
[17:29:41.109]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.109]         }
[17:29:41.109]         base::close(...future.stdout)
[17:29:41.109]         ...future.stdout <- NULL
[17:29:41.109]     }
[17:29:41.109]     ...future.result$conditions <- ...future.conditions
[17:29:41.109]     ...future.result$finished <- base::Sys.time()
[17:29:41.109]     ...future.result
[17:29:41.109] }
[17:29:41.114] assign_globals() ...
[17:29:41.114] List of 1
[17:29:41.114]  $ x: int [1:4] 0 1 2 3
[17:29:41.114]  - attr(*, "where")=List of 1
[17:29:41.114]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.114]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.114]  - attr(*, "resolved")= logi FALSE
[17:29:41.114]  - attr(*, "total_size")= int 133
[17:29:41.114]  - attr(*, "already-done")= logi TRUE
[17:29:41.118] - copied 'x' to environment
[17:29:41.118] assign_globals() ... done
[17:29:41.119] plan(): Setting new future strategy stack:
[17:29:41.119] List of future strategies:
[17:29:41.119] 1. sequential:
[17:29:41.119]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.119]    - tweaked: FALSE
[17:29:41.119]    - call: NULL
[17:29:41.120] plan(): nbrOfWorkers() = 1
[17:29:41.122] plan(): Setting new future strategy stack:
[17:29:41.122] List of future strategies:
[17:29:41.122] 1. sequential:
[17:29:41.122]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.122]    - tweaked: FALSE
[17:29:41.122]    - call: plan(strategy)
[17:29:41.123] plan(): nbrOfWorkers() = 1
[17:29:41.123] SequentialFuture started (and completed)
[17:29:41.124] - Launch lazy future ... done
[17:29:41.124] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_3-78525'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add5f5f1b8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.126] getGlobalsAndPackages() ...
[17:29:41.126] Searching for globals...
[17:29:41.128] - globals found: [3] '{', 'sample', 'x'
[17:29:41.128] Searching for globals ... DONE
[17:29:41.128] Resolving globals: FALSE
[17:29:41.129] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.130] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.130] - globals: [1] 'x'
[17:29:41.130] 
[17:29:41.131] getGlobalsAndPackages() ... DONE
[17:29:41.131] run() for 'Future' ...
[17:29:41.132] - state: 'created'
[17:29:41.132] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.133] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.133] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.133]   - Field: 'label'
[17:29:41.133]   - Field: 'local'
[17:29:41.134]   - Field: 'owner'
[17:29:41.134]   - Field: 'envir'
[17:29:41.134]   - Field: 'packages'
[17:29:41.135]   - Field: 'gc'
[17:29:41.135]   - Field: 'conditions'
[17:29:41.135]   - Field: 'expr'
[17:29:41.135]   - Field: 'uuid'
[17:29:41.136]   - Field: 'seed'
[17:29:41.136]   - Field: 'version'
[17:29:41.136]   - Field: 'result'
[17:29:41.137]   - Field: 'asynchronous'
[17:29:41.137]   - Field: 'calls'
[17:29:41.137]   - Field: 'globals'
[17:29:41.138]   - Field: 'stdout'
[17:29:41.138]   - Field: 'earlySignal'
[17:29:41.138]   - Field: 'lazy'
[17:29:41.138]   - Field: 'state'
[17:29:41.139] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.139] - Launch lazy future ...
[17:29:41.139] Packages needed by the future expression (n = 0): <none>
[17:29:41.140] Packages needed by future strategies (n = 0): <none>
[17:29:41.141] {
[17:29:41.141]     {
[17:29:41.141]         {
[17:29:41.141]             ...future.startTime <- base::Sys.time()
[17:29:41.141]             {
[17:29:41.141]                 {
[17:29:41.141]                   {
[17:29:41.141]                     base::local({
[17:29:41.141]                       has_future <- base::requireNamespace("future", 
[17:29:41.141]                         quietly = TRUE)
[17:29:41.141]                       if (has_future) {
[17:29:41.141]                         ns <- base::getNamespace("future")
[17:29:41.141]                         version <- ns[[".package"]][["version"]]
[17:29:41.141]                         if (is.null(version)) 
[17:29:41.141]                           version <- utils::packageVersion("future")
[17:29:41.141]                       }
[17:29:41.141]                       else {
[17:29:41.141]                         version <- NULL
[17:29:41.141]                       }
[17:29:41.141]                       if (!has_future || version < "1.8.0") {
[17:29:41.141]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.141]                           "", base::R.version$version.string), 
[17:29:41.141]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.141]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.141]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.141]                             "release", "version")], collapse = " "), 
[17:29:41.141]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.141]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.141]                           info)
[17:29:41.141]                         info <- base::paste(info, collapse = "; ")
[17:29:41.141]                         if (!has_future) {
[17:29:41.141]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.141]                             info)
[17:29:41.141]                         }
[17:29:41.141]                         else {
[17:29:41.141]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.141]                             info, version)
[17:29:41.141]                         }
[17:29:41.141]                         base::stop(msg)
[17:29:41.141]                       }
[17:29:41.141]                     })
[17:29:41.141]                   }
[17:29:41.141]                   ...future.strategy.old <- future::plan("list")
[17:29:41.141]                   options(future.plan = NULL)
[17:29:41.141]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.141]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.141]                 }
[17:29:41.141]                 ...future.workdir <- getwd()
[17:29:41.141]             }
[17:29:41.141]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.141]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.141]         }
[17:29:41.141]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.141]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.141]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.141]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.141]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.141]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.141]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.141]             base::names(...future.oldOptions))
[17:29:41.141]     }
[17:29:41.141]     if (FALSE) {
[17:29:41.141]     }
[17:29:41.141]     else {
[17:29:41.141]         if (TRUE) {
[17:29:41.141]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.141]                 open = "w")
[17:29:41.141]         }
[17:29:41.141]         else {
[17:29:41.141]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.141]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.141]         }
[17:29:41.141]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.141]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.141]             base::sink(type = "output", split = FALSE)
[17:29:41.141]             base::close(...future.stdout)
[17:29:41.141]         }, add = TRUE)
[17:29:41.141]     }
[17:29:41.141]     ...future.frame <- base::sys.nframe()
[17:29:41.141]     ...future.conditions <- base::list()
[17:29:41.141]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.141]     if (FALSE) {
[17:29:41.141]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.141]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.141]     }
[17:29:41.141]     ...future.result <- base::tryCatch({
[17:29:41.141]         base::withCallingHandlers({
[17:29:41.141]             ...future.value <- base::withVisible(base::local({
[17:29:41.141]                 sample(x, size = 1L)
[17:29:41.141]             }))
[17:29:41.141]             future::FutureResult(value = ...future.value$value, 
[17:29:41.141]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.141]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.141]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.141]                     ...future.globalenv.names))
[17:29:41.141]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.141]         }, condition = base::local({
[17:29:41.141]             c <- base::c
[17:29:41.141]             inherits <- base::inherits
[17:29:41.141]             invokeRestart <- base::invokeRestart
[17:29:41.141]             length <- base::length
[17:29:41.141]             list <- base::list
[17:29:41.141]             seq.int <- base::seq.int
[17:29:41.141]             signalCondition <- base::signalCondition
[17:29:41.141]             sys.calls <- base::sys.calls
[17:29:41.141]             `[[` <- base::`[[`
[17:29:41.141]             `+` <- base::`+`
[17:29:41.141]             `<<-` <- base::`<<-`
[17:29:41.141]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.141]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.141]                   3L)]
[17:29:41.141]             }
[17:29:41.141]             function(cond) {
[17:29:41.141]                 is_error <- inherits(cond, "error")
[17:29:41.141]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.141]                   NULL)
[17:29:41.141]                 if (is_error) {
[17:29:41.141]                   sessionInformation <- function() {
[17:29:41.141]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.141]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.141]                       search = base::search(), system = base::Sys.info())
[17:29:41.141]                   }
[17:29:41.141]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.141]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.141]                     cond$call), session = sessionInformation(), 
[17:29:41.141]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.141]                   signalCondition(cond)
[17:29:41.141]                 }
[17:29:41.141]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.141]                 "immediateCondition"))) {
[17:29:41.141]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.141]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.141]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.141]                   if (TRUE && !signal) {
[17:29:41.141]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.141]                     {
[17:29:41.141]                       inherits <- base::inherits
[17:29:41.141]                       invokeRestart <- base::invokeRestart
[17:29:41.141]                       is.null <- base::is.null
[17:29:41.141]                       muffled <- FALSE
[17:29:41.141]                       if (inherits(cond, "message")) {
[17:29:41.141]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.141]                         if (muffled) 
[17:29:41.141]                           invokeRestart("muffleMessage")
[17:29:41.141]                       }
[17:29:41.141]                       else if (inherits(cond, "warning")) {
[17:29:41.141]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.141]                         if (muffled) 
[17:29:41.141]                           invokeRestart("muffleWarning")
[17:29:41.141]                       }
[17:29:41.141]                       else if (inherits(cond, "condition")) {
[17:29:41.141]                         if (!is.null(pattern)) {
[17:29:41.141]                           computeRestarts <- base::computeRestarts
[17:29:41.141]                           grepl <- base::grepl
[17:29:41.141]                           restarts <- computeRestarts(cond)
[17:29:41.141]                           for (restart in restarts) {
[17:29:41.141]                             name <- restart$name
[17:29:41.141]                             if (is.null(name)) 
[17:29:41.141]                               next
[17:29:41.141]                             if (!grepl(pattern, name)) 
[17:29:41.141]                               next
[17:29:41.141]                             invokeRestart(restart)
[17:29:41.141]                             muffled <- TRUE
[17:29:41.141]                             break
[17:29:41.141]                           }
[17:29:41.141]                         }
[17:29:41.141]                       }
[17:29:41.141]                       invisible(muffled)
[17:29:41.141]                     }
[17:29:41.141]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.141]                   }
[17:29:41.141]                 }
[17:29:41.141]                 else {
[17:29:41.141]                   if (TRUE) {
[17:29:41.141]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.141]                     {
[17:29:41.141]                       inherits <- base::inherits
[17:29:41.141]                       invokeRestart <- base::invokeRestart
[17:29:41.141]                       is.null <- base::is.null
[17:29:41.141]                       muffled <- FALSE
[17:29:41.141]                       if (inherits(cond, "message")) {
[17:29:41.141]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.141]                         if (muffled) 
[17:29:41.141]                           invokeRestart("muffleMessage")
[17:29:41.141]                       }
[17:29:41.141]                       else if (inherits(cond, "warning")) {
[17:29:41.141]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.141]                         if (muffled) 
[17:29:41.141]                           invokeRestart("muffleWarning")
[17:29:41.141]                       }
[17:29:41.141]                       else if (inherits(cond, "condition")) {
[17:29:41.141]                         if (!is.null(pattern)) {
[17:29:41.141]                           computeRestarts <- base::computeRestarts
[17:29:41.141]                           grepl <- base::grepl
[17:29:41.141]                           restarts <- computeRestarts(cond)
[17:29:41.141]                           for (restart in restarts) {
[17:29:41.141]                             name <- restart$name
[17:29:41.141]                             if (is.null(name)) 
[17:29:41.141]                               next
[17:29:41.141]                             if (!grepl(pattern, name)) 
[17:29:41.141]                               next
[17:29:41.141]                             invokeRestart(restart)
[17:29:41.141]                             muffled <- TRUE
[17:29:41.141]                             break
[17:29:41.141]                           }
[17:29:41.141]                         }
[17:29:41.141]                       }
[17:29:41.141]                       invisible(muffled)
[17:29:41.141]                     }
[17:29:41.141]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.141]                   }
[17:29:41.141]                 }
[17:29:41.141]             }
[17:29:41.141]         }))
[17:29:41.141]     }, error = function(ex) {
[17:29:41.141]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.141]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.141]                 ...future.rng), started = ...future.startTime, 
[17:29:41.141]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.141]             version = "1.8"), class = "FutureResult")
[17:29:41.141]     }, finally = {
[17:29:41.141]         if (!identical(...future.workdir, getwd())) 
[17:29:41.141]             setwd(...future.workdir)
[17:29:41.141]         {
[17:29:41.141]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.141]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.141]             }
[17:29:41.141]             base::options(...future.oldOptions)
[17:29:41.141]             if (.Platform$OS.type == "windows") {
[17:29:41.141]                 old_names <- names(...future.oldEnvVars)
[17:29:41.141]                 envs <- base::Sys.getenv()
[17:29:41.141]                 names <- names(envs)
[17:29:41.141]                 common <- intersect(names, old_names)
[17:29:41.141]                 added <- setdiff(names, old_names)
[17:29:41.141]                 removed <- setdiff(old_names, names)
[17:29:41.141]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.141]                   envs[common]]
[17:29:41.141]                 NAMES <- toupper(changed)
[17:29:41.141]                 args <- list()
[17:29:41.141]                 for (kk in seq_along(NAMES)) {
[17:29:41.141]                   name <- changed[[kk]]
[17:29:41.141]                   NAME <- NAMES[[kk]]
[17:29:41.141]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.141]                     next
[17:29:41.141]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.141]                 }
[17:29:41.141]                 NAMES <- toupper(added)
[17:29:41.141]                 for (kk in seq_along(NAMES)) {
[17:29:41.141]                   name <- added[[kk]]
[17:29:41.141]                   NAME <- NAMES[[kk]]
[17:29:41.141]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.141]                     next
[17:29:41.141]                   args[[name]] <- ""
[17:29:41.141]                 }
[17:29:41.141]                 NAMES <- toupper(removed)
[17:29:41.141]                 for (kk in seq_along(NAMES)) {
[17:29:41.141]                   name <- removed[[kk]]
[17:29:41.141]                   NAME <- NAMES[[kk]]
[17:29:41.141]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.141]                     next
[17:29:41.141]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.141]                 }
[17:29:41.141]                 if (length(args) > 0) 
[17:29:41.141]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.141]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.141]             }
[17:29:41.141]             else {
[17:29:41.141]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.141]             }
[17:29:41.141]             {
[17:29:41.141]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.141]                   0L) {
[17:29:41.141]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.141]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.141]                   base::options(opts)
[17:29:41.141]                 }
[17:29:41.141]                 {
[17:29:41.141]                   {
[17:29:41.141]                     base::assign(".Random.seed", c(10407L, -1747872794L, 
[17:29:41.141]                     81576118L, 1436872011L, -1518356641L, -1757990257L, 
[17:29:41.141]                     1928374916L), envir = base::globalenv(), 
[17:29:41.141]                       inherits = FALSE)
[17:29:41.141]                     NULL
[17:29:41.141]                   }
[17:29:41.141]                   options(future.plan = NULL)
[17:29:41.141]                   if (is.na(NA_character_)) 
[17:29:41.141]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.141]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.141]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.141]                     .init = FALSE)
[17:29:41.141]                 }
[17:29:41.141]             }
[17:29:41.141]         }
[17:29:41.141]     })
[17:29:41.141]     if (TRUE) {
[17:29:41.141]         base::sink(type = "output", split = FALSE)
[17:29:41.141]         if (TRUE) {
[17:29:41.141]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.141]         }
[17:29:41.141]         else {
[17:29:41.141]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.141]         }
[17:29:41.141]         base::close(...future.stdout)
[17:29:41.141]         ...future.stdout <- NULL
[17:29:41.141]     }
[17:29:41.141]     ...future.result$conditions <- ...future.conditions
[17:29:41.141]     ...future.result$finished <- base::Sys.time()
[17:29:41.141]     ...future.result
[17:29:41.141] }
[17:29:41.146] assign_globals() ...
[17:29:41.147] List of 1
[17:29:41.147]  $ x: int [1:4] 0 1 2 3
[17:29:41.147]  - attr(*, "where")=List of 1
[17:29:41.147]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.147]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.147]  - attr(*, "resolved")= logi FALSE
[17:29:41.147]  - attr(*, "total_size")= int 133
[17:29:41.147]  - attr(*, "already-done")= logi TRUE
[17:29:41.150] - copied 'x' to environment
[17:29:41.150] assign_globals() ... done
[17:29:41.151] plan(): Setting new future strategy stack:
[17:29:41.151] List of future strategies:
[17:29:41.151] 1. sequential:
[17:29:41.151]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.151]    - tweaked: FALSE
[17:29:41.151]    - call: NULL
[17:29:41.152] plan(): nbrOfWorkers() = 1
[17:29:41.156] plan(): Setting new future strategy stack:
[17:29:41.156] List of future strategies:
[17:29:41.156] 1. sequential:
[17:29:41.156]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.156]    - tweaked: FALSE
[17:29:41.156]    - call: plan(strategy)
[17:29:41.157] plan(): nbrOfWorkers() = 1
[17:29:41.158] SequentialFuture started (and completed)
[17:29:41.158] - Launch lazy future ... done
[17:29:41.158] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_4-385717'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add5f5f1b8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.160] resolve() on list ...
[17:29:41.160]  recursive: 0
[17:29:41.161]  length: 4
[17:29:41.161] 
[17:29:41.161] resolved() for 'SequentialFuture' ...
[17:29:41.162] - state: 'finished'
[17:29:41.162] - run: TRUE
[17:29:41.162] - result: 'FutureResult'
[17:29:41.162] resolved() for 'SequentialFuture' ... done
[17:29:41.163] Future #1
[17:29:41.163] signalConditionsASAP(SequentialFuture, pos=1) ...
[17:29:41.163] - nx: 4
[17:29:41.164] - relay: TRUE
[17:29:41.164] - stdout: TRUE
[17:29:41.164] - signal: TRUE
[17:29:41.164] - resignal: FALSE
[17:29:41.165] - force: TRUE
[17:29:41.165] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:41.165] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:41.165]  - until=1
[17:29:41.166]  - relaying element #1
[17:29:41.166] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:41.166] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:41.167] signalConditionsASAP(SequentialFuture, pos=1) ... done
[17:29:41.167]  length: 3 (resolved future 1)
[17:29:41.167] resolved() for 'SequentialFuture' ...
[17:29:41.168] - state: 'finished'
[17:29:41.168] - run: TRUE
[17:29:41.168] - result: 'FutureResult'
[17:29:41.169] resolved() for 'SequentialFuture' ... done
[17:29:41.169] Future #2
[17:29:41.169] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:29:41.169] - nx: 4
[17:29:41.170] - relay: TRUE
[17:29:41.170] - stdout: TRUE
[17:29:41.170] - signal: TRUE
[17:29:41.171] - resignal: FALSE
[17:29:41.171] - force: TRUE
[17:29:41.171] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:41.171] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:41.172]  - until=2
[17:29:41.172]  - relaying element #2
[17:29:41.172] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:41.173] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:41.173] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:29:41.173]  length: 2 (resolved future 2)
[17:29:41.174] resolved() for 'SequentialFuture' ...
[17:29:41.174] - state: 'finished'
[17:29:41.174] - run: TRUE
[17:29:41.174] - result: 'FutureResult'
[17:29:41.175] resolved() for 'SequentialFuture' ... done
[17:29:41.175] Future #3
[17:29:41.175] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:29:41.176] - nx: 4
[17:29:41.176] - relay: TRUE
[17:29:41.176] - stdout: TRUE
[17:29:41.176] - signal: TRUE
[17:29:41.177] - resignal: FALSE
[17:29:41.177] - force: TRUE
[17:29:41.177] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:41.178] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:41.178]  - until=3
[17:29:41.178]  - relaying element #3
[17:29:41.178] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:41.179] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:41.179] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:29:41.179]  length: 1 (resolved future 3)
[17:29:41.179] resolved() for 'SequentialFuture' ...
[17:29:41.180] - state: 'finished'
[17:29:41.180] - run: TRUE
[17:29:41.180] - result: 'FutureResult'
[17:29:41.180] resolved() for 'SequentialFuture' ... done
[17:29:41.181] Future #4
[17:29:41.181] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:29:41.181] - nx: 4
[17:29:41.182] - relay: TRUE
[17:29:41.182] - stdout: TRUE
[17:29:41.182] - signal: TRUE
[17:29:41.182] - resignal: FALSE
[17:29:41.182] - force: TRUE
[17:29:41.183] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:41.183] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:41.183]  - until=4
[17:29:41.183]  - relaying element #4
[17:29:41.184] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:41.184] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:41.184] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:29:41.184]  length: 0 (resolved future 4)
[17:29:41.184] Relaying remaining futures
[17:29:41.185] signalConditionsASAP(NULL, pos=0) ...
[17:29:41.185] - nx: 4
[17:29:41.185] - relay: TRUE
[17:29:41.185] - stdout: TRUE
[17:29:41.186] - signal: TRUE
[17:29:41.186] - resignal: FALSE
[17:29:41.186] - force: TRUE
[17:29:41.186] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:41.187] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:29:41.187] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:41.188] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:41.188] signalConditionsASAP(NULL, pos=0) ... done
[17:29:41.188] resolve() on list ... DONE
[[1]]
[1] 1

[[2]]
[1] 1

[[3]]
[1] 3

[[4]]
[1] 3

[17:29:41.189] getGlobalsAndPackages() ...
[17:29:41.190] Searching for globals...
[17:29:41.192] - globals found: [3] '{', 'sample', 'x'
[17:29:41.192] Searching for globals ... DONE
[17:29:41.192] Resolving globals: FALSE
[17:29:41.193] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.194] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.194] - globals: [1] 'x'
[17:29:41.194] 
[17:29:41.195] getGlobalsAndPackages() ... DONE
[17:29:41.195] run() for 'Future' ...
[17:29:41.196] - state: 'created'
[17:29:41.196] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.196] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.197] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.197]   - Field: 'label'
[17:29:41.197]   - Field: 'local'
[17:29:41.197]   - Field: 'owner'
[17:29:41.197]   - Field: 'envir'
[17:29:41.197]   - Field: 'packages'
[17:29:41.198]   - Field: 'gc'
[17:29:41.198]   - Field: 'conditions'
[17:29:41.198]   - Field: 'expr'
[17:29:41.198]   - Field: 'uuid'
[17:29:41.198]   - Field: 'seed'
[17:29:41.198]   - Field: 'version'
[17:29:41.199]   - Field: 'result'
[17:29:41.199]   - Field: 'asynchronous'
[17:29:41.199]   - Field: 'calls'
[17:29:41.199]   - Field: 'globals'
[17:29:41.199]   - Field: 'stdout'
[17:29:41.200]   - Field: 'earlySignal'
[17:29:41.200]   - Field: 'lazy'
[17:29:41.200]   - Field: 'state'
[17:29:41.200] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.200] - Launch lazy future ...
[17:29:41.201] Packages needed by the future expression (n = 0): <none>
[17:29:41.201] Packages needed by future strategies (n = 0): <none>
[17:29:41.201] {
[17:29:41.201]     {
[17:29:41.201]         {
[17:29:41.201]             ...future.startTime <- base::Sys.time()
[17:29:41.201]             {
[17:29:41.201]                 {
[17:29:41.201]                   {
[17:29:41.201]                     base::local({
[17:29:41.201]                       has_future <- base::requireNamespace("future", 
[17:29:41.201]                         quietly = TRUE)
[17:29:41.201]                       if (has_future) {
[17:29:41.201]                         ns <- base::getNamespace("future")
[17:29:41.201]                         version <- ns[[".package"]][["version"]]
[17:29:41.201]                         if (is.null(version)) 
[17:29:41.201]                           version <- utils::packageVersion("future")
[17:29:41.201]                       }
[17:29:41.201]                       else {
[17:29:41.201]                         version <- NULL
[17:29:41.201]                       }
[17:29:41.201]                       if (!has_future || version < "1.8.0") {
[17:29:41.201]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.201]                           "", base::R.version$version.string), 
[17:29:41.201]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.201]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.201]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.201]                             "release", "version")], collapse = " "), 
[17:29:41.201]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.201]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.201]                           info)
[17:29:41.201]                         info <- base::paste(info, collapse = "; ")
[17:29:41.201]                         if (!has_future) {
[17:29:41.201]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.201]                             info)
[17:29:41.201]                         }
[17:29:41.201]                         else {
[17:29:41.201]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.201]                             info, version)
[17:29:41.201]                         }
[17:29:41.201]                         base::stop(msg)
[17:29:41.201]                       }
[17:29:41.201]                     })
[17:29:41.201]                   }
[17:29:41.201]                   ...future.strategy.old <- future::plan("list")
[17:29:41.201]                   options(future.plan = NULL)
[17:29:41.201]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.201]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.201]                 }
[17:29:41.201]                 ...future.workdir <- getwd()
[17:29:41.201]             }
[17:29:41.201]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.201]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.201]         }
[17:29:41.201]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.201]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.201]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.201]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.201]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.201]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.201]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.201]             base::names(...future.oldOptions))
[17:29:41.201]     }
[17:29:41.201]     if (FALSE) {
[17:29:41.201]     }
[17:29:41.201]     else {
[17:29:41.201]         if (TRUE) {
[17:29:41.201]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.201]                 open = "w")
[17:29:41.201]         }
[17:29:41.201]         else {
[17:29:41.201]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.201]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.201]         }
[17:29:41.201]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.201]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.201]             base::sink(type = "output", split = FALSE)
[17:29:41.201]             base::close(...future.stdout)
[17:29:41.201]         }, add = TRUE)
[17:29:41.201]     }
[17:29:41.201]     ...future.frame <- base::sys.nframe()
[17:29:41.201]     ...future.conditions <- base::list()
[17:29:41.201]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.201]     if (FALSE) {
[17:29:41.201]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.201]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.201]     }
[17:29:41.201]     ...future.result <- base::tryCatch({
[17:29:41.201]         base::withCallingHandlers({
[17:29:41.201]             ...future.value <- base::withVisible(base::local({
[17:29:41.201]                 sample(x, size = 1L)
[17:29:41.201]             }))
[17:29:41.201]             future::FutureResult(value = ...future.value$value, 
[17:29:41.201]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.201]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.201]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.201]                     ...future.globalenv.names))
[17:29:41.201]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.201]         }, condition = base::local({
[17:29:41.201]             c <- base::c
[17:29:41.201]             inherits <- base::inherits
[17:29:41.201]             invokeRestart <- base::invokeRestart
[17:29:41.201]             length <- base::length
[17:29:41.201]             list <- base::list
[17:29:41.201]             seq.int <- base::seq.int
[17:29:41.201]             signalCondition <- base::signalCondition
[17:29:41.201]             sys.calls <- base::sys.calls
[17:29:41.201]             `[[` <- base::`[[`
[17:29:41.201]             `+` <- base::`+`
[17:29:41.201]             `<<-` <- base::`<<-`
[17:29:41.201]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.201]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.201]                   3L)]
[17:29:41.201]             }
[17:29:41.201]             function(cond) {
[17:29:41.201]                 is_error <- inherits(cond, "error")
[17:29:41.201]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.201]                   NULL)
[17:29:41.201]                 if (is_error) {
[17:29:41.201]                   sessionInformation <- function() {
[17:29:41.201]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.201]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.201]                       search = base::search(), system = base::Sys.info())
[17:29:41.201]                   }
[17:29:41.201]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.201]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.201]                     cond$call), session = sessionInformation(), 
[17:29:41.201]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.201]                   signalCondition(cond)
[17:29:41.201]                 }
[17:29:41.201]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.201]                 "immediateCondition"))) {
[17:29:41.201]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.201]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.201]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.201]                   if (TRUE && !signal) {
[17:29:41.201]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.201]                     {
[17:29:41.201]                       inherits <- base::inherits
[17:29:41.201]                       invokeRestart <- base::invokeRestart
[17:29:41.201]                       is.null <- base::is.null
[17:29:41.201]                       muffled <- FALSE
[17:29:41.201]                       if (inherits(cond, "message")) {
[17:29:41.201]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.201]                         if (muffled) 
[17:29:41.201]                           invokeRestart("muffleMessage")
[17:29:41.201]                       }
[17:29:41.201]                       else if (inherits(cond, "warning")) {
[17:29:41.201]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.201]                         if (muffled) 
[17:29:41.201]                           invokeRestart("muffleWarning")
[17:29:41.201]                       }
[17:29:41.201]                       else if (inherits(cond, "condition")) {
[17:29:41.201]                         if (!is.null(pattern)) {
[17:29:41.201]                           computeRestarts <- base::computeRestarts
[17:29:41.201]                           grepl <- base::grepl
[17:29:41.201]                           restarts <- computeRestarts(cond)
[17:29:41.201]                           for (restart in restarts) {
[17:29:41.201]                             name <- restart$name
[17:29:41.201]                             if (is.null(name)) 
[17:29:41.201]                               next
[17:29:41.201]                             if (!grepl(pattern, name)) 
[17:29:41.201]                               next
[17:29:41.201]                             invokeRestart(restart)
[17:29:41.201]                             muffled <- TRUE
[17:29:41.201]                             break
[17:29:41.201]                           }
[17:29:41.201]                         }
[17:29:41.201]                       }
[17:29:41.201]                       invisible(muffled)
[17:29:41.201]                     }
[17:29:41.201]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.201]                   }
[17:29:41.201]                 }
[17:29:41.201]                 else {
[17:29:41.201]                   if (TRUE) {
[17:29:41.201]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.201]                     {
[17:29:41.201]                       inherits <- base::inherits
[17:29:41.201]                       invokeRestart <- base::invokeRestart
[17:29:41.201]                       is.null <- base::is.null
[17:29:41.201]                       muffled <- FALSE
[17:29:41.201]                       if (inherits(cond, "message")) {
[17:29:41.201]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.201]                         if (muffled) 
[17:29:41.201]                           invokeRestart("muffleMessage")
[17:29:41.201]                       }
[17:29:41.201]                       else if (inherits(cond, "warning")) {
[17:29:41.201]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.201]                         if (muffled) 
[17:29:41.201]                           invokeRestart("muffleWarning")
[17:29:41.201]                       }
[17:29:41.201]                       else if (inherits(cond, "condition")) {
[17:29:41.201]                         if (!is.null(pattern)) {
[17:29:41.201]                           computeRestarts <- base::computeRestarts
[17:29:41.201]                           grepl <- base::grepl
[17:29:41.201]                           restarts <- computeRestarts(cond)
[17:29:41.201]                           for (restart in restarts) {
[17:29:41.201]                             name <- restart$name
[17:29:41.201]                             if (is.null(name)) 
[17:29:41.201]                               next
[17:29:41.201]                             if (!grepl(pattern, name)) 
[17:29:41.201]                               next
[17:29:41.201]                             invokeRestart(restart)
[17:29:41.201]                             muffled <- TRUE
[17:29:41.201]                             break
[17:29:41.201]                           }
[17:29:41.201]                         }
[17:29:41.201]                       }
[17:29:41.201]                       invisible(muffled)
[17:29:41.201]                     }
[17:29:41.201]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.201]                   }
[17:29:41.201]                 }
[17:29:41.201]             }
[17:29:41.201]         }))
[17:29:41.201]     }, error = function(ex) {
[17:29:41.201]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.201]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.201]                 ...future.rng), started = ...future.startTime, 
[17:29:41.201]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.201]             version = "1.8"), class = "FutureResult")
[17:29:41.201]     }, finally = {
[17:29:41.201]         if (!identical(...future.workdir, getwd())) 
[17:29:41.201]             setwd(...future.workdir)
[17:29:41.201]         {
[17:29:41.201]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.201]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.201]             }
[17:29:41.201]             base::options(...future.oldOptions)
[17:29:41.201]             if (.Platform$OS.type == "windows") {
[17:29:41.201]                 old_names <- names(...future.oldEnvVars)
[17:29:41.201]                 envs <- base::Sys.getenv()
[17:29:41.201]                 names <- names(envs)
[17:29:41.201]                 common <- intersect(names, old_names)
[17:29:41.201]                 added <- setdiff(names, old_names)
[17:29:41.201]                 removed <- setdiff(old_names, names)
[17:29:41.201]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.201]                   envs[common]]
[17:29:41.201]                 NAMES <- toupper(changed)
[17:29:41.201]                 args <- list()
[17:29:41.201]                 for (kk in seq_along(NAMES)) {
[17:29:41.201]                   name <- changed[[kk]]
[17:29:41.201]                   NAME <- NAMES[[kk]]
[17:29:41.201]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.201]                     next
[17:29:41.201]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.201]                 }
[17:29:41.201]                 NAMES <- toupper(added)
[17:29:41.201]                 for (kk in seq_along(NAMES)) {
[17:29:41.201]                   name <- added[[kk]]
[17:29:41.201]                   NAME <- NAMES[[kk]]
[17:29:41.201]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.201]                     next
[17:29:41.201]                   args[[name]] <- ""
[17:29:41.201]                 }
[17:29:41.201]                 NAMES <- toupper(removed)
[17:29:41.201]                 for (kk in seq_along(NAMES)) {
[17:29:41.201]                   name <- removed[[kk]]
[17:29:41.201]                   NAME <- NAMES[[kk]]
[17:29:41.201]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.201]                     next
[17:29:41.201]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.201]                 }
[17:29:41.201]                 if (length(args) > 0) 
[17:29:41.201]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.201]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.201]             }
[17:29:41.201]             else {
[17:29:41.201]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.201]             }
[17:29:41.201]             {
[17:29:41.201]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.201]                   0L) {
[17:29:41.201]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.201]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.201]                   base::options(opts)
[17:29:41.201]                 }
[17:29:41.201]                 {
[17:29:41.201]                   {
[17:29:41.201]                     base::assign(".Random.seed", c(10407L, 1905472070L, 
[17:29:41.201]                     548552339L, -2132515101L, -5027275L, -1254720561L, 
[17:29:41.201]                     -249581963L), envir = base::globalenv(), 
[17:29:41.201]                       inherits = FALSE)
[17:29:41.201]                     NULL
[17:29:41.201]                   }
[17:29:41.201]                   options(future.plan = NULL)
[17:29:41.201]                   if (is.na(NA_character_)) 
[17:29:41.201]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.201]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.201]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.201]                     .init = FALSE)
[17:29:41.201]                 }
[17:29:41.201]             }
[17:29:41.201]         }
[17:29:41.201]     })
[17:29:41.201]     if (TRUE) {
[17:29:41.201]         base::sink(type = "output", split = FALSE)
[17:29:41.201]         if (TRUE) {
[17:29:41.201]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.201]         }
[17:29:41.201]         else {
[17:29:41.201]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.201]         }
[17:29:41.201]         base::close(...future.stdout)
[17:29:41.201]         ...future.stdout <- NULL
[17:29:41.201]     }
[17:29:41.201]     ...future.result$conditions <- ...future.conditions
[17:29:41.201]     ...future.result$finished <- base::Sys.time()
[17:29:41.201]     ...future.result
[17:29:41.201] }
[17:29:41.205] assign_globals() ...
[17:29:41.205] List of 1
[17:29:41.205]  $ x: int [1:4] 0 1 2 3
[17:29:41.205]  - attr(*, "where")=List of 1
[17:29:41.205]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.205]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.205]  - attr(*, "resolved")= logi FALSE
[17:29:41.205]  - attr(*, "total_size")= int 133
[17:29:41.205]  - attr(*, "already-done")= logi TRUE
[17:29:41.212] - copied 'x' to environment
[17:29:41.213] assign_globals() ... done
[17:29:41.213] plan(): Setting new future strategy stack:
[17:29:41.214] List of future strategies:
[17:29:41.214] 1. sequential:
[17:29:41.214]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.214]    - tweaked: FALSE
[17:29:41.214]    - call: NULL
[17:29:41.215] plan(): nbrOfWorkers() = 1
[17:29:41.216] plan(): Setting new future strategy stack:
[17:29:41.217] List of future strategies:
[17:29:41.217] 1. sequential:
[17:29:41.217]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.217]    - tweaked: FALSE
[17:29:41.217]    - call: plan(strategy)
[17:29:41.218] plan(): nbrOfWorkers() = 1
[17:29:41.218] SequentialFuture started (and completed)
[17:29:41.218] - Launch lazy future ... done
[17:29:41.219] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_1-757701'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add7513b18
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.220] getGlobalsAndPackages() ...
[17:29:41.220] Searching for globals...
[17:29:41.222] - globals found: [3] '{', 'sample', 'x'
[17:29:41.223] Searching for globals ... DONE
[17:29:41.223] Resolving globals: FALSE
[17:29:41.224] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.224] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.225] - globals: [1] 'x'
[17:29:41.225] 
[17:29:41.225] getGlobalsAndPackages() ... DONE
[17:29:41.226] run() for 'Future' ...
[17:29:41.226] - state: 'created'
[17:29:41.226] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.227] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.227] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.227]   - Field: 'label'
[17:29:41.228]   - Field: 'local'
[17:29:41.228]   - Field: 'owner'
[17:29:41.228]   - Field: 'envir'
[17:29:41.229]   - Field: 'packages'
[17:29:41.229]   - Field: 'gc'
[17:29:41.229]   - Field: 'conditions'
[17:29:41.229]   - Field: 'expr'
[17:29:41.230]   - Field: 'uuid'
[17:29:41.230]   - Field: 'seed'
[17:29:41.230]   - Field: 'version'
[17:29:41.230]   - Field: 'result'
[17:29:41.231]   - Field: 'asynchronous'
[17:29:41.231]   - Field: 'calls'
[17:29:41.231]   - Field: 'globals'
[17:29:41.232]   - Field: 'stdout'
[17:29:41.232]   - Field: 'earlySignal'
[17:29:41.232]   - Field: 'lazy'
[17:29:41.232]   - Field: 'state'
[17:29:41.233] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.233] - Launch lazy future ...
[17:29:41.233] Packages needed by the future expression (n = 0): <none>
[17:29:41.234] Packages needed by future strategies (n = 0): <none>
[17:29:41.235] {
[17:29:41.235]     {
[17:29:41.235]         {
[17:29:41.235]             ...future.startTime <- base::Sys.time()
[17:29:41.235]             {
[17:29:41.235]                 {
[17:29:41.235]                   {
[17:29:41.235]                     base::local({
[17:29:41.235]                       has_future <- base::requireNamespace("future", 
[17:29:41.235]                         quietly = TRUE)
[17:29:41.235]                       if (has_future) {
[17:29:41.235]                         ns <- base::getNamespace("future")
[17:29:41.235]                         version <- ns[[".package"]][["version"]]
[17:29:41.235]                         if (is.null(version)) 
[17:29:41.235]                           version <- utils::packageVersion("future")
[17:29:41.235]                       }
[17:29:41.235]                       else {
[17:29:41.235]                         version <- NULL
[17:29:41.235]                       }
[17:29:41.235]                       if (!has_future || version < "1.8.0") {
[17:29:41.235]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.235]                           "", base::R.version$version.string), 
[17:29:41.235]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.235]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.235]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.235]                             "release", "version")], collapse = " "), 
[17:29:41.235]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.235]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.235]                           info)
[17:29:41.235]                         info <- base::paste(info, collapse = "; ")
[17:29:41.235]                         if (!has_future) {
[17:29:41.235]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.235]                             info)
[17:29:41.235]                         }
[17:29:41.235]                         else {
[17:29:41.235]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.235]                             info, version)
[17:29:41.235]                         }
[17:29:41.235]                         base::stop(msg)
[17:29:41.235]                       }
[17:29:41.235]                     })
[17:29:41.235]                   }
[17:29:41.235]                   ...future.strategy.old <- future::plan("list")
[17:29:41.235]                   options(future.plan = NULL)
[17:29:41.235]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.235]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.235]                 }
[17:29:41.235]                 ...future.workdir <- getwd()
[17:29:41.235]             }
[17:29:41.235]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.235]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.235]         }
[17:29:41.235]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.235]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.235]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.235]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.235]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.235]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.235]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.235]             base::names(...future.oldOptions))
[17:29:41.235]     }
[17:29:41.235]     if (FALSE) {
[17:29:41.235]     }
[17:29:41.235]     else {
[17:29:41.235]         if (TRUE) {
[17:29:41.235]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.235]                 open = "w")
[17:29:41.235]         }
[17:29:41.235]         else {
[17:29:41.235]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.235]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.235]         }
[17:29:41.235]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.235]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.235]             base::sink(type = "output", split = FALSE)
[17:29:41.235]             base::close(...future.stdout)
[17:29:41.235]         }, add = TRUE)
[17:29:41.235]     }
[17:29:41.235]     ...future.frame <- base::sys.nframe()
[17:29:41.235]     ...future.conditions <- base::list()
[17:29:41.235]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.235]     if (FALSE) {
[17:29:41.235]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.235]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.235]     }
[17:29:41.235]     ...future.result <- base::tryCatch({
[17:29:41.235]         base::withCallingHandlers({
[17:29:41.235]             ...future.value <- base::withVisible(base::local({
[17:29:41.235]                 sample(x, size = 1L)
[17:29:41.235]             }))
[17:29:41.235]             future::FutureResult(value = ...future.value$value, 
[17:29:41.235]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.235]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.235]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.235]                     ...future.globalenv.names))
[17:29:41.235]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.235]         }, condition = base::local({
[17:29:41.235]             c <- base::c
[17:29:41.235]             inherits <- base::inherits
[17:29:41.235]             invokeRestart <- base::invokeRestart
[17:29:41.235]             length <- base::length
[17:29:41.235]             list <- base::list
[17:29:41.235]             seq.int <- base::seq.int
[17:29:41.235]             signalCondition <- base::signalCondition
[17:29:41.235]             sys.calls <- base::sys.calls
[17:29:41.235]             `[[` <- base::`[[`
[17:29:41.235]             `+` <- base::`+`
[17:29:41.235]             `<<-` <- base::`<<-`
[17:29:41.235]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.235]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.235]                   3L)]
[17:29:41.235]             }
[17:29:41.235]             function(cond) {
[17:29:41.235]                 is_error <- inherits(cond, "error")
[17:29:41.235]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.235]                   NULL)
[17:29:41.235]                 if (is_error) {
[17:29:41.235]                   sessionInformation <- function() {
[17:29:41.235]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.235]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.235]                       search = base::search(), system = base::Sys.info())
[17:29:41.235]                   }
[17:29:41.235]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.235]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.235]                     cond$call), session = sessionInformation(), 
[17:29:41.235]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.235]                   signalCondition(cond)
[17:29:41.235]                 }
[17:29:41.235]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.235]                 "immediateCondition"))) {
[17:29:41.235]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.235]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.235]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.235]                   if (TRUE && !signal) {
[17:29:41.235]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.235]                     {
[17:29:41.235]                       inherits <- base::inherits
[17:29:41.235]                       invokeRestart <- base::invokeRestart
[17:29:41.235]                       is.null <- base::is.null
[17:29:41.235]                       muffled <- FALSE
[17:29:41.235]                       if (inherits(cond, "message")) {
[17:29:41.235]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.235]                         if (muffled) 
[17:29:41.235]                           invokeRestart("muffleMessage")
[17:29:41.235]                       }
[17:29:41.235]                       else if (inherits(cond, "warning")) {
[17:29:41.235]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.235]                         if (muffled) 
[17:29:41.235]                           invokeRestart("muffleWarning")
[17:29:41.235]                       }
[17:29:41.235]                       else if (inherits(cond, "condition")) {
[17:29:41.235]                         if (!is.null(pattern)) {
[17:29:41.235]                           computeRestarts <- base::computeRestarts
[17:29:41.235]                           grepl <- base::grepl
[17:29:41.235]                           restarts <- computeRestarts(cond)
[17:29:41.235]                           for (restart in restarts) {
[17:29:41.235]                             name <- restart$name
[17:29:41.235]                             if (is.null(name)) 
[17:29:41.235]                               next
[17:29:41.235]                             if (!grepl(pattern, name)) 
[17:29:41.235]                               next
[17:29:41.235]                             invokeRestart(restart)
[17:29:41.235]                             muffled <- TRUE
[17:29:41.235]                             break
[17:29:41.235]                           }
[17:29:41.235]                         }
[17:29:41.235]                       }
[17:29:41.235]                       invisible(muffled)
[17:29:41.235]                     }
[17:29:41.235]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.235]                   }
[17:29:41.235]                 }
[17:29:41.235]                 else {
[17:29:41.235]                   if (TRUE) {
[17:29:41.235]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.235]                     {
[17:29:41.235]                       inherits <- base::inherits
[17:29:41.235]                       invokeRestart <- base::invokeRestart
[17:29:41.235]                       is.null <- base::is.null
[17:29:41.235]                       muffled <- FALSE
[17:29:41.235]                       if (inherits(cond, "message")) {
[17:29:41.235]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.235]                         if (muffled) 
[17:29:41.235]                           invokeRestart("muffleMessage")
[17:29:41.235]                       }
[17:29:41.235]                       else if (inherits(cond, "warning")) {
[17:29:41.235]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.235]                         if (muffled) 
[17:29:41.235]                           invokeRestart("muffleWarning")
[17:29:41.235]                       }
[17:29:41.235]                       else if (inherits(cond, "condition")) {
[17:29:41.235]                         if (!is.null(pattern)) {
[17:29:41.235]                           computeRestarts <- base::computeRestarts
[17:29:41.235]                           grepl <- base::grepl
[17:29:41.235]                           restarts <- computeRestarts(cond)
[17:29:41.235]                           for (restart in restarts) {
[17:29:41.235]                             name <- restart$name
[17:29:41.235]                             if (is.null(name)) 
[17:29:41.235]                               next
[17:29:41.235]                             if (!grepl(pattern, name)) 
[17:29:41.235]                               next
[17:29:41.235]                             invokeRestart(restart)
[17:29:41.235]                             muffled <- TRUE
[17:29:41.235]                             break
[17:29:41.235]                           }
[17:29:41.235]                         }
[17:29:41.235]                       }
[17:29:41.235]                       invisible(muffled)
[17:29:41.235]                     }
[17:29:41.235]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.235]                   }
[17:29:41.235]                 }
[17:29:41.235]             }
[17:29:41.235]         }))
[17:29:41.235]     }, error = function(ex) {
[17:29:41.235]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.235]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.235]                 ...future.rng), started = ...future.startTime, 
[17:29:41.235]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.235]             version = "1.8"), class = "FutureResult")
[17:29:41.235]     }, finally = {
[17:29:41.235]         if (!identical(...future.workdir, getwd())) 
[17:29:41.235]             setwd(...future.workdir)
[17:29:41.235]         {
[17:29:41.235]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.235]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.235]             }
[17:29:41.235]             base::options(...future.oldOptions)
[17:29:41.235]             if (.Platform$OS.type == "windows") {
[17:29:41.235]                 old_names <- names(...future.oldEnvVars)
[17:29:41.235]                 envs <- base::Sys.getenv()
[17:29:41.235]                 names <- names(envs)
[17:29:41.235]                 common <- intersect(names, old_names)
[17:29:41.235]                 added <- setdiff(names, old_names)
[17:29:41.235]                 removed <- setdiff(old_names, names)
[17:29:41.235]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.235]                   envs[common]]
[17:29:41.235]                 NAMES <- toupper(changed)
[17:29:41.235]                 args <- list()
[17:29:41.235]                 for (kk in seq_along(NAMES)) {
[17:29:41.235]                   name <- changed[[kk]]
[17:29:41.235]                   NAME <- NAMES[[kk]]
[17:29:41.235]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.235]                     next
[17:29:41.235]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.235]                 }
[17:29:41.235]                 NAMES <- toupper(added)
[17:29:41.235]                 for (kk in seq_along(NAMES)) {
[17:29:41.235]                   name <- added[[kk]]
[17:29:41.235]                   NAME <- NAMES[[kk]]
[17:29:41.235]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.235]                     next
[17:29:41.235]                   args[[name]] <- ""
[17:29:41.235]                 }
[17:29:41.235]                 NAMES <- toupper(removed)
[17:29:41.235]                 for (kk in seq_along(NAMES)) {
[17:29:41.235]                   name <- removed[[kk]]
[17:29:41.235]                   NAME <- NAMES[[kk]]
[17:29:41.235]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.235]                     next
[17:29:41.235]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.235]                 }
[17:29:41.235]                 if (length(args) > 0) 
[17:29:41.235]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.235]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.235]             }
[17:29:41.235]             else {
[17:29:41.235]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.235]             }
[17:29:41.235]             {
[17:29:41.235]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.235]                   0L) {
[17:29:41.235]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.235]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.235]                   base::options(opts)
[17:29:41.235]                 }
[17:29:41.235]                 {
[17:29:41.235]                   {
[17:29:41.235]                     base::assign(".Random.seed", c(10407L, -2132515101L, 
[17:29:41.235]                     -1686425357L, -1357819733L, -249581963L, 
[17:29:41.235]                     -289910035L, -92677537L), envir = base::globalenv(), 
[17:29:41.235]                       inherits = FALSE)
[17:29:41.235]                     NULL
[17:29:41.235]                   }
[17:29:41.235]                   options(future.plan = NULL)
[17:29:41.235]                   if (is.na(NA_character_)) 
[17:29:41.235]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.235]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.235]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.235]                     .init = FALSE)
[17:29:41.235]                 }
[17:29:41.235]             }
[17:29:41.235]         }
[17:29:41.235]     })
[17:29:41.235]     if (TRUE) {
[17:29:41.235]         base::sink(type = "output", split = FALSE)
[17:29:41.235]         if (TRUE) {
[17:29:41.235]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.235]         }
[17:29:41.235]         else {
[17:29:41.235]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.235]         }
[17:29:41.235]         base::close(...future.stdout)
[17:29:41.235]         ...future.stdout <- NULL
[17:29:41.235]     }
[17:29:41.235]     ...future.result$conditions <- ...future.conditions
[17:29:41.235]     ...future.result$finished <- base::Sys.time()
[17:29:41.235]     ...future.result
[17:29:41.235] }
[17:29:41.241] assign_globals() ...
[17:29:41.241] List of 1
[17:29:41.241]  $ x: int [1:4] 0 1 2 3
[17:29:41.241]  - attr(*, "where")=List of 1
[17:29:41.241]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.241]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.241]  - attr(*, "resolved")= logi FALSE
[17:29:41.241]  - attr(*, "total_size")= int 133
[17:29:41.241]  - attr(*, "already-done")= logi TRUE
[17:29:41.245] - copied 'x' to environment
[17:29:41.246] assign_globals() ... done
[17:29:41.246] plan(): Setting new future strategy stack:
[17:29:41.247] List of future strategies:
[17:29:41.247] 1. sequential:
[17:29:41.247]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.247]    - tweaked: FALSE
[17:29:41.247]    - call: NULL
[17:29:41.247] plan(): nbrOfWorkers() = 1
[17:29:41.249] plan(): Setting new future strategy stack:
[17:29:41.250] List of future strategies:
[17:29:41.250] 1. sequential:
[17:29:41.250]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.250]    - tweaked: FALSE
[17:29:41.250]    - call: plan(strategy)
[17:29:41.250] plan(): nbrOfWorkers() = 1
[17:29:41.251] SequentialFuture started (and completed)
[17:29:41.251] - Launch lazy future ... done
[17:29:41.251] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_2-177304'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add7513b18
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.253] getGlobalsAndPackages() ...
[17:29:41.253] Searching for globals...
[17:29:41.255] - globals found: [3] '{', 'sample', 'x'
[17:29:41.255] Searching for globals ... DONE
[17:29:41.256] Resolving globals: FALSE
[17:29:41.256] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.259] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.259] - globals: [1] 'x'
[17:29:41.260] 
[17:29:41.260] getGlobalsAndPackages() ... DONE
[17:29:41.260] run() for 'Future' ...
[17:29:41.261] - state: 'created'
[17:29:41.261] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.262] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.262] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.262]   - Field: 'label'
[17:29:41.263]   - Field: 'local'
[17:29:41.263]   - Field: 'owner'
[17:29:41.263]   - Field: 'envir'
[17:29:41.264]   - Field: 'packages'
[17:29:41.264]   - Field: 'gc'
[17:29:41.264]   - Field: 'conditions'
[17:29:41.264]   - Field: 'expr'
[17:29:41.265]   - Field: 'uuid'
[17:29:41.265]   - Field: 'seed'
[17:29:41.265]   - Field: 'version'
[17:29:41.266]   - Field: 'result'
[17:29:41.266]   - Field: 'asynchronous'
[17:29:41.266]   - Field: 'calls'
[17:29:41.266]   - Field: 'globals'
[17:29:41.267]   - Field: 'stdout'
[17:29:41.267]   - Field: 'earlySignal'
[17:29:41.267]   - Field: 'lazy'
[17:29:41.267]   - Field: 'state'
[17:29:41.268] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.268] - Launch lazy future ...
[17:29:41.268] Packages needed by the future expression (n = 0): <none>
[17:29:41.269] Packages needed by future strategies (n = 0): <none>
[17:29:41.269] {
[17:29:41.269]     {
[17:29:41.269]         {
[17:29:41.269]             ...future.startTime <- base::Sys.time()
[17:29:41.269]             {
[17:29:41.269]                 {
[17:29:41.269]                   {
[17:29:41.269]                     base::local({
[17:29:41.269]                       has_future <- base::requireNamespace("future", 
[17:29:41.269]                         quietly = TRUE)
[17:29:41.269]                       if (has_future) {
[17:29:41.269]                         ns <- base::getNamespace("future")
[17:29:41.269]                         version <- ns[[".package"]][["version"]]
[17:29:41.269]                         if (is.null(version)) 
[17:29:41.269]                           version <- utils::packageVersion("future")
[17:29:41.269]                       }
[17:29:41.269]                       else {
[17:29:41.269]                         version <- NULL
[17:29:41.269]                       }
[17:29:41.269]                       if (!has_future || version < "1.8.0") {
[17:29:41.269]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.269]                           "", base::R.version$version.string), 
[17:29:41.269]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.269]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.269]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.269]                             "release", "version")], collapse = " "), 
[17:29:41.269]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.269]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.269]                           info)
[17:29:41.269]                         info <- base::paste(info, collapse = "; ")
[17:29:41.269]                         if (!has_future) {
[17:29:41.269]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.269]                             info)
[17:29:41.269]                         }
[17:29:41.269]                         else {
[17:29:41.269]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.269]                             info, version)
[17:29:41.269]                         }
[17:29:41.269]                         base::stop(msg)
[17:29:41.269]                       }
[17:29:41.269]                     })
[17:29:41.269]                   }
[17:29:41.269]                   ...future.strategy.old <- future::plan("list")
[17:29:41.269]                   options(future.plan = NULL)
[17:29:41.269]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.269]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.269]                 }
[17:29:41.269]                 ...future.workdir <- getwd()
[17:29:41.269]             }
[17:29:41.269]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.269]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.269]         }
[17:29:41.269]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.269]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.269]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.269]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.269]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.269]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.269]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.269]             base::names(...future.oldOptions))
[17:29:41.269]     }
[17:29:41.269]     if (FALSE) {
[17:29:41.269]     }
[17:29:41.269]     else {
[17:29:41.269]         if (TRUE) {
[17:29:41.269]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.269]                 open = "w")
[17:29:41.269]         }
[17:29:41.269]         else {
[17:29:41.269]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.269]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.269]         }
[17:29:41.269]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.269]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.269]             base::sink(type = "output", split = FALSE)
[17:29:41.269]             base::close(...future.stdout)
[17:29:41.269]         }, add = TRUE)
[17:29:41.269]     }
[17:29:41.269]     ...future.frame <- base::sys.nframe()
[17:29:41.269]     ...future.conditions <- base::list()
[17:29:41.269]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.269]     if (FALSE) {
[17:29:41.269]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.269]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.269]     }
[17:29:41.269]     ...future.result <- base::tryCatch({
[17:29:41.269]         base::withCallingHandlers({
[17:29:41.269]             ...future.value <- base::withVisible(base::local({
[17:29:41.269]                 sample(x, size = 1L)
[17:29:41.269]             }))
[17:29:41.269]             future::FutureResult(value = ...future.value$value, 
[17:29:41.269]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.269]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.269]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.269]                     ...future.globalenv.names))
[17:29:41.269]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.269]         }, condition = base::local({
[17:29:41.269]             c <- base::c
[17:29:41.269]             inherits <- base::inherits
[17:29:41.269]             invokeRestart <- base::invokeRestart
[17:29:41.269]             length <- base::length
[17:29:41.269]             list <- base::list
[17:29:41.269]             seq.int <- base::seq.int
[17:29:41.269]             signalCondition <- base::signalCondition
[17:29:41.269]             sys.calls <- base::sys.calls
[17:29:41.269]             `[[` <- base::`[[`
[17:29:41.269]             `+` <- base::`+`
[17:29:41.269]             `<<-` <- base::`<<-`
[17:29:41.269]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.269]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.269]                   3L)]
[17:29:41.269]             }
[17:29:41.269]             function(cond) {
[17:29:41.269]                 is_error <- inherits(cond, "error")
[17:29:41.269]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.269]                   NULL)
[17:29:41.269]                 if (is_error) {
[17:29:41.269]                   sessionInformation <- function() {
[17:29:41.269]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.269]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.269]                       search = base::search(), system = base::Sys.info())
[17:29:41.269]                   }
[17:29:41.269]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.269]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.269]                     cond$call), session = sessionInformation(), 
[17:29:41.269]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.269]                   signalCondition(cond)
[17:29:41.269]                 }
[17:29:41.269]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.269]                 "immediateCondition"))) {
[17:29:41.269]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.269]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.269]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.269]                   if (TRUE && !signal) {
[17:29:41.269]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.269]                     {
[17:29:41.269]                       inherits <- base::inherits
[17:29:41.269]                       invokeRestart <- base::invokeRestart
[17:29:41.269]                       is.null <- base::is.null
[17:29:41.269]                       muffled <- FALSE
[17:29:41.269]                       if (inherits(cond, "message")) {
[17:29:41.269]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.269]                         if (muffled) 
[17:29:41.269]                           invokeRestart("muffleMessage")
[17:29:41.269]                       }
[17:29:41.269]                       else if (inherits(cond, "warning")) {
[17:29:41.269]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.269]                         if (muffled) 
[17:29:41.269]                           invokeRestart("muffleWarning")
[17:29:41.269]                       }
[17:29:41.269]                       else if (inherits(cond, "condition")) {
[17:29:41.269]                         if (!is.null(pattern)) {
[17:29:41.269]                           computeRestarts <- base::computeRestarts
[17:29:41.269]                           grepl <- base::grepl
[17:29:41.269]                           restarts <- computeRestarts(cond)
[17:29:41.269]                           for (restart in restarts) {
[17:29:41.269]                             name <- restart$name
[17:29:41.269]                             if (is.null(name)) 
[17:29:41.269]                               next
[17:29:41.269]                             if (!grepl(pattern, name)) 
[17:29:41.269]                               next
[17:29:41.269]                             invokeRestart(restart)
[17:29:41.269]                             muffled <- TRUE
[17:29:41.269]                             break
[17:29:41.269]                           }
[17:29:41.269]                         }
[17:29:41.269]                       }
[17:29:41.269]                       invisible(muffled)
[17:29:41.269]                     }
[17:29:41.269]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.269]                   }
[17:29:41.269]                 }
[17:29:41.269]                 else {
[17:29:41.269]                   if (TRUE) {
[17:29:41.269]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.269]                     {
[17:29:41.269]                       inherits <- base::inherits
[17:29:41.269]                       invokeRestart <- base::invokeRestart
[17:29:41.269]                       is.null <- base::is.null
[17:29:41.269]                       muffled <- FALSE
[17:29:41.269]                       if (inherits(cond, "message")) {
[17:29:41.269]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.269]                         if (muffled) 
[17:29:41.269]                           invokeRestart("muffleMessage")
[17:29:41.269]                       }
[17:29:41.269]                       else if (inherits(cond, "warning")) {
[17:29:41.269]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.269]                         if (muffled) 
[17:29:41.269]                           invokeRestart("muffleWarning")
[17:29:41.269]                       }
[17:29:41.269]                       else if (inherits(cond, "condition")) {
[17:29:41.269]                         if (!is.null(pattern)) {
[17:29:41.269]                           computeRestarts <- base::computeRestarts
[17:29:41.269]                           grepl <- base::grepl
[17:29:41.269]                           restarts <- computeRestarts(cond)
[17:29:41.269]                           for (restart in restarts) {
[17:29:41.269]                             name <- restart$name
[17:29:41.269]                             if (is.null(name)) 
[17:29:41.269]                               next
[17:29:41.269]                             if (!grepl(pattern, name)) 
[17:29:41.269]                               next
[17:29:41.269]                             invokeRestart(restart)
[17:29:41.269]                             muffled <- TRUE
[17:29:41.269]                             break
[17:29:41.269]                           }
[17:29:41.269]                         }
[17:29:41.269]                       }
[17:29:41.269]                       invisible(muffled)
[17:29:41.269]                     }
[17:29:41.269]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.269]                   }
[17:29:41.269]                 }
[17:29:41.269]             }
[17:29:41.269]         }))
[17:29:41.269]     }, error = function(ex) {
[17:29:41.269]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.269]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.269]                 ...future.rng), started = ...future.startTime, 
[17:29:41.269]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.269]             version = "1.8"), class = "FutureResult")
[17:29:41.269]     }, finally = {
[17:29:41.269]         if (!identical(...future.workdir, getwd())) 
[17:29:41.269]             setwd(...future.workdir)
[17:29:41.269]         {
[17:29:41.269]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.269]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.269]             }
[17:29:41.269]             base::options(...future.oldOptions)
[17:29:41.269]             if (.Platform$OS.type == "windows") {
[17:29:41.269]                 old_names <- names(...future.oldEnvVars)
[17:29:41.269]                 envs <- base::Sys.getenv()
[17:29:41.269]                 names <- names(envs)
[17:29:41.269]                 common <- intersect(names, old_names)
[17:29:41.269]                 added <- setdiff(names, old_names)
[17:29:41.269]                 removed <- setdiff(old_names, names)
[17:29:41.269]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.269]                   envs[common]]
[17:29:41.269]                 NAMES <- toupper(changed)
[17:29:41.269]                 args <- list()
[17:29:41.269]                 for (kk in seq_along(NAMES)) {
[17:29:41.269]                   name <- changed[[kk]]
[17:29:41.269]                   NAME <- NAMES[[kk]]
[17:29:41.269]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.269]                     next
[17:29:41.269]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.269]                 }
[17:29:41.269]                 NAMES <- toupper(added)
[17:29:41.269]                 for (kk in seq_along(NAMES)) {
[17:29:41.269]                   name <- added[[kk]]
[17:29:41.269]                   NAME <- NAMES[[kk]]
[17:29:41.269]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.269]                     next
[17:29:41.269]                   args[[name]] <- ""
[17:29:41.269]                 }
[17:29:41.269]                 NAMES <- toupper(removed)
[17:29:41.269]                 for (kk in seq_along(NAMES)) {
[17:29:41.269]                   name <- removed[[kk]]
[17:29:41.269]                   NAME <- NAMES[[kk]]
[17:29:41.269]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.269]                     next
[17:29:41.269]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.269]                 }
[17:29:41.269]                 if (length(args) > 0) 
[17:29:41.269]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.269]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.269]             }
[17:29:41.269]             else {
[17:29:41.269]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.269]             }
[17:29:41.269]             {
[17:29:41.269]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.269]                   0L) {
[17:29:41.269]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.269]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.269]                   base::options(opts)
[17:29:41.269]                 }
[17:29:41.269]                 {
[17:29:41.269]                   {
[17:29:41.269]                     base::assign(".Random.seed", c(10407L, -1357819733L, 
[17:29:41.269]                     -1161049300L, -252299846L, -92677537L, 1519979774L, 
[17:29:41.269]                     -1585431857L), envir = base::globalenv(), 
[17:29:41.269]                       inherits = FALSE)
[17:29:41.269]                     NULL
[17:29:41.269]                   }
[17:29:41.269]                   options(future.plan = NULL)
[17:29:41.269]                   if (is.na(NA_character_)) 
[17:29:41.269]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.269]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.269]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.269]                     .init = FALSE)
[17:29:41.269]                 }
[17:29:41.269]             }
[17:29:41.269]         }
[17:29:41.269]     })
[17:29:41.269]     if (TRUE) {
[17:29:41.269]         base::sink(type = "output", split = FALSE)
[17:29:41.269]         if (TRUE) {
[17:29:41.269]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.269]         }
[17:29:41.269]         else {
[17:29:41.269]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.269]         }
[17:29:41.269]         base::close(...future.stdout)
[17:29:41.269]         ...future.stdout <- NULL
[17:29:41.269]     }
[17:29:41.269]     ...future.result$conditions <- ...future.conditions
[17:29:41.269]     ...future.result$finished <- base::Sys.time()
[17:29:41.269]     ...future.result
[17:29:41.269] }
[17:29:41.275] assign_globals() ...
[17:29:41.275] List of 1
[17:29:41.275]  $ x: int [1:4] 0 1 2 3
[17:29:41.275]  - attr(*, "where")=List of 1
[17:29:41.275]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.275]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.275]  - attr(*, "resolved")= logi FALSE
[17:29:41.275]  - attr(*, "total_size")= int 133
[17:29:41.275]  - attr(*, "already-done")= logi TRUE
[17:29:41.280] - copied 'x' to environment
[17:29:41.280] assign_globals() ... done
[17:29:41.281] plan(): Setting new future strategy stack:
[17:29:41.281] List of future strategies:
[17:29:41.281] 1. sequential:
[17:29:41.281]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.281]    - tweaked: FALSE
[17:29:41.281]    - call: NULL
[17:29:41.282] plan(): nbrOfWorkers() = 1
[17:29:41.284] plan(): Setting new future strategy stack:
[17:29:41.284] List of future strategies:
[17:29:41.284] 1. sequential:
[17:29:41.284]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.284]    - tweaked: FALSE
[17:29:41.284]    - call: plan(strategy)
[17:29:41.285] plan(): nbrOfWorkers() = 1
[17:29:41.285] SequentialFuture started (and completed)
[17:29:41.285] - Launch lazy future ... done
[17:29:41.286] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_3-151414'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add7513b18
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.287] getGlobalsAndPackages() ...
[17:29:41.287] Searching for globals...
[17:29:41.289] - globals found: [3] '{', 'sample', 'x'
[17:29:41.290] Searching for globals ... DONE
[17:29:41.290] Resolving globals: FALSE
[17:29:41.291] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.291] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.292] - globals: [1] 'x'
[17:29:41.292] 
[17:29:41.292] getGlobalsAndPackages() ... DONE
[17:29:41.293] run() for 'Future' ...
[17:29:41.293] - state: 'created'
[17:29:41.293] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.294] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.294] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.295]   - Field: 'label'
[17:29:41.295]   - Field: 'local'
[17:29:41.295]   - Field: 'owner'
[17:29:41.296]   - Field: 'envir'
[17:29:41.296]   - Field: 'packages'
[17:29:41.296]   - Field: 'gc'
[17:29:41.297]   - Field: 'conditions'
[17:29:41.297]   - Field: 'expr'
[17:29:41.297]   - Field: 'uuid'
[17:29:41.297]   - Field: 'seed'
[17:29:41.298]   - Field: 'version'
[17:29:41.298]   - Field: 'result'
[17:29:41.298]   - Field: 'asynchronous'
[17:29:41.299]   - Field: 'calls'
[17:29:41.299]   - Field: 'globals'
[17:29:41.299]   - Field: 'stdout'
[17:29:41.300]   - Field: 'earlySignal'
[17:29:41.300]   - Field: 'lazy'
[17:29:41.300]   - Field: 'state'
[17:29:41.300] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.301] - Launch lazy future ...
[17:29:41.301] Packages needed by the future expression (n = 0): <none>
[17:29:41.302] Packages needed by future strategies (n = 0): <none>
[17:29:41.303] {
[17:29:41.303]     {
[17:29:41.303]         {
[17:29:41.303]             ...future.startTime <- base::Sys.time()
[17:29:41.303]             {
[17:29:41.303]                 {
[17:29:41.303]                   {
[17:29:41.303]                     base::local({
[17:29:41.303]                       has_future <- base::requireNamespace("future", 
[17:29:41.303]                         quietly = TRUE)
[17:29:41.303]                       if (has_future) {
[17:29:41.303]                         ns <- base::getNamespace("future")
[17:29:41.303]                         version <- ns[[".package"]][["version"]]
[17:29:41.303]                         if (is.null(version)) 
[17:29:41.303]                           version <- utils::packageVersion("future")
[17:29:41.303]                       }
[17:29:41.303]                       else {
[17:29:41.303]                         version <- NULL
[17:29:41.303]                       }
[17:29:41.303]                       if (!has_future || version < "1.8.0") {
[17:29:41.303]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.303]                           "", base::R.version$version.string), 
[17:29:41.303]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.303]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.303]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.303]                             "release", "version")], collapse = " "), 
[17:29:41.303]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.303]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.303]                           info)
[17:29:41.303]                         info <- base::paste(info, collapse = "; ")
[17:29:41.303]                         if (!has_future) {
[17:29:41.303]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.303]                             info)
[17:29:41.303]                         }
[17:29:41.303]                         else {
[17:29:41.303]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.303]                             info, version)
[17:29:41.303]                         }
[17:29:41.303]                         base::stop(msg)
[17:29:41.303]                       }
[17:29:41.303]                     })
[17:29:41.303]                   }
[17:29:41.303]                   ...future.strategy.old <- future::plan("list")
[17:29:41.303]                   options(future.plan = NULL)
[17:29:41.303]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.303]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.303]                 }
[17:29:41.303]                 ...future.workdir <- getwd()
[17:29:41.303]             }
[17:29:41.303]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.303]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.303]         }
[17:29:41.303]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.303]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.303]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.303]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.303]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.303]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.303]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.303]             base::names(...future.oldOptions))
[17:29:41.303]     }
[17:29:41.303]     if (FALSE) {
[17:29:41.303]     }
[17:29:41.303]     else {
[17:29:41.303]         if (TRUE) {
[17:29:41.303]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.303]                 open = "w")
[17:29:41.303]         }
[17:29:41.303]         else {
[17:29:41.303]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.303]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.303]         }
[17:29:41.303]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.303]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.303]             base::sink(type = "output", split = FALSE)
[17:29:41.303]             base::close(...future.stdout)
[17:29:41.303]         }, add = TRUE)
[17:29:41.303]     }
[17:29:41.303]     ...future.frame <- base::sys.nframe()
[17:29:41.303]     ...future.conditions <- base::list()
[17:29:41.303]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.303]     if (FALSE) {
[17:29:41.303]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.303]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.303]     }
[17:29:41.303]     ...future.result <- base::tryCatch({
[17:29:41.303]         base::withCallingHandlers({
[17:29:41.303]             ...future.value <- base::withVisible(base::local({
[17:29:41.303]                 sample(x, size = 1L)
[17:29:41.303]             }))
[17:29:41.303]             future::FutureResult(value = ...future.value$value, 
[17:29:41.303]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.303]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.303]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.303]                     ...future.globalenv.names))
[17:29:41.303]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.303]         }, condition = base::local({
[17:29:41.303]             c <- base::c
[17:29:41.303]             inherits <- base::inherits
[17:29:41.303]             invokeRestart <- base::invokeRestart
[17:29:41.303]             length <- base::length
[17:29:41.303]             list <- base::list
[17:29:41.303]             seq.int <- base::seq.int
[17:29:41.303]             signalCondition <- base::signalCondition
[17:29:41.303]             sys.calls <- base::sys.calls
[17:29:41.303]             `[[` <- base::`[[`
[17:29:41.303]             `+` <- base::`+`
[17:29:41.303]             `<<-` <- base::`<<-`
[17:29:41.303]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.303]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.303]                   3L)]
[17:29:41.303]             }
[17:29:41.303]             function(cond) {
[17:29:41.303]                 is_error <- inherits(cond, "error")
[17:29:41.303]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.303]                   NULL)
[17:29:41.303]                 if (is_error) {
[17:29:41.303]                   sessionInformation <- function() {
[17:29:41.303]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.303]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.303]                       search = base::search(), system = base::Sys.info())
[17:29:41.303]                   }
[17:29:41.303]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.303]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.303]                     cond$call), session = sessionInformation(), 
[17:29:41.303]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.303]                   signalCondition(cond)
[17:29:41.303]                 }
[17:29:41.303]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.303]                 "immediateCondition"))) {
[17:29:41.303]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.303]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.303]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.303]                   if (TRUE && !signal) {
[17:29:41.303]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.303]                     {
[17:29:41.303]                       inherits <- base::inherits
[17:29:41.303]                       invokeRestart <- base::invokeRestart
[17:29:41.303]                       is.null <- base::is.null
[17:29:41.303]                       muffled <- FALSE
[17:29:41.303]                       if (inherits(cond, "message")) {
[17:29:41.303]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.303]                         if (muffled) 
[17:29:41.303]                           invokeRestart("muffleMessage")
[17:29:41.303]                       }
[17:29:41.303]                       else if (inherits(cond, "warning")) {
[17:29:41.303]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.303]                         if (muffled) 
[17:29:41.303]                           invokeRestart("muffleWarning")
[17:29:41.303]                       }
[17:29:41.303]                       else if (inherits(cond, "condition")) {
[17:29:41.303]                         if (!is.null(pattern)) {
[17:29:41.303]                           computeRestarts <- base::computeRestarts
[17:29:41.303]                           grepl <- base::grepl
[17:29:41.303]                           restarts <- computeRestarts(cond)
[17:29:41.303]                           for (restart in restarts) {
[17:29:41.303]                             name <- restart$name
[17:29:41.303]                             if (is.null(name)) 
[17:29:41.303]                               next
[17:29:41.303]                             if (!grepl(pattern, name)) 
[17:29:41.303]                               next
[17:29:41.303]                             invokeRestart(restart)
[17:29:41.303]                             muffled <- TRUE
[17:29:41.303]                             break
[17:29:41.303]                           }
[17:29:41.303]                         }
[17:29:41.303]                       }
[17:29:41.303]                       invisible(muffled)
[17:29:41.303]                     }
[17:29:41.303]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.303]                   }
[17:29:41.303]                 }
[17:29:41.303]                 else {
[17:29:41.303]                   if (TRUE) {
[17:29:41.303]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.303]                     {
[17:29:41.303]                       inherits <- base::inherits
[17:29:41.303]                       invokeRestart <- base::invokeRestart
[17:29:41.303]                       is.null <- base::is.null
[17:29:41.303]                       muffled <- FALSE
[17:29:41.303]                       if (inherits(cond, "message")) {
[17:29:41.303]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.303]                         if (muffled) 
[17:29:41.303]                           invokeRestart("muffleMessage")
[17:29:41.303]                       }
[17:29:41.303]                       else if (inherits(cond, "warning")) {
[17:29:41.303]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.303]                         if (muffled) 
[17:29:41.303]                           invokeRestart("muffleWarning")
[17:29:41.303]                       }
[17:29:41.303]                       else if (inherits(cond, "condition")) {
[17:29:41.303]                         if (!is.null(pattern)) {
[17:29:41.303]                           computeRestarts <- base::computeRestarts
[17:29:41.303]                           grepl <- base::grepl
[17:29:41.303]                           restarts <- computeRestarts(cond)
[17:29:41.303]                           for (restart in restarts) {
[17:29:41.303]                             name <- restart$name
[17:29:41.303]                             if (is.null(name)) 
[17:29:41.303]                               next
[17:29:41.303]                             if (!grepl(pattern, name)) 
[17:29:41.303]                               next
[17:29:41.303]                             invokeRestart(restart)
[17:29:41.303]                             muffled <- TRUE
[17:29:41.303]                             break
[17:29:41.303]                           }
[17:29:41.303]                         }
[17:29:41.303]                       }
[17:29:41.303]                       invisible(muffled)
[17:29:41.303]                     }
[17:29:41.303]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.303]                   }
[17:29:41.303]                 }
[17:29:41.303]             }
[17:29:41.303]         }))
[17:29:41.303]     }, error = function(ex) {
[17:29:41.303]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.303]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.303]                 ...future.rng), started = ...future.startTime, 
[17:29:41.303]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.303]             version = "1.8"), class = "FutureResult")
[17:29:41.303]     }, finally = {
[17:29:41.303]         if (!identical(...future.workdir, getwd())) 
[17:29:41.303]             setwd(...future.workdir)
[17:29:41.303]         {
[17:29:41.303]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.303]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.303]             }
[17:29:41.303]             base::options(...future.oldOptions)
[17:29:41.303]             if (.Platform$OS.type == "windows") {
[17:29:41.303]                 old_names <- names(...future.oldEnvVars)
[17:29:41.303]                 envs <- base::Sys.getenv()
[17:29:41.303]                 names <- names(envs)
[17:29:41.303]                 common <- intersect(names, old_names)
[17:29:41.303]                 added <- setdiff(names, old_names)
[17:29:41.303]                 removed <- setdiff(old_names, names)
[17:29:41.303]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.303]                   envs[common]]
[17:29:41.303]                 NAMES <- toupper(changed)
[17:29:41.303]                 args <- list()
[17:29:41.303]                 for (kk in seq_along(NAMES)) {
[17:29:41.303]                   name <- changed[[kk]]
[17:29:41.303]                   NAME <- NAMES[[kk]]
[17:29:41.303]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.303]                     next
[17:29:41.303]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.303]                 }
[17:29:41.303]                 NAMES <- toupper(added)
[17:29:41.303]                 for (kk in seq_along(NAMES)) {
[17:29:41.303]                   name <- added[[kk]]
[17:29:41.303]                   NAME <- NAMES[[kk]]
[17:29:41.303]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.303]                     next
[17:29:41.303]                   args[[name]] <- ""
[17:29:41.303]                 }
[17:29:41.303]                 NAMES <- toupper(removed)
[17:29:41.303]                 for (kk in seq_along(NAMES)) {
[17:29:41.303]                   name <- removed[[kk]]
[17:29:41.303]                   NAME <- NAMES[[kk]]
[17:29:41.303]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.303]                     next
[17:29:41.303]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.303]                 }
[17:29:41.303]                 if (length(args) > 0) 
[17:29:41.303]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.303]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.303]             }
[17:29:41.303]             else {
[17:29:41.303]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.303]             }
[17:29:41.303]             {
[17:29:41.303]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.303]                   0L) {
[17:29:41.303]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.303]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.303]                   base::options(opts)
[17:29:41.303]                 }
[17:29:41.303]                 {
[17:29:41.303]                   {
[17:29:41.303]                     base::assign(".Random.seed", c(10407L, -252299846L, 
[17:29:41.303]                     1961593306L, -1257450365L, -1585431857L, 
[17:29:41.303]                     1137698484L, 1475741235L), envir = base::globalenv(), 
[17:29:41.303]                       inherits = FALSE)
[17:29:41.303]                     NULL
[17:29:41.303]                   }
[17:29:41.303]                   options(future.plan = NULL)
[17:29:41.303]                   if (is.na(NA_character_)) 
[17:29:41.303]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.303]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.303]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.303]                     .init = FALSE)
[17:29:41.303]                 }
[17:29:41.303]             }
[17:29:41.303]         }
[17:29:41.303]     })
[17:29:41.303]     if (TRUE) {
[17:29:41.303]         base::sink(type = "output", split = FALSE)
[17:29:41.303]         if (TRUE) {
[17:29:41.303]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.303]         }
[17:29:41.303]         else {
[17:29:41.303]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.303]         }
[17:29:41.303]         base::close(...future.stdout)
[17:29:41.303]         ...future.stdout <- NULL
[17:29:41.303]     }
[17:29:41.303]     ...future.result$conditions <- ...future.conditions
[17:29:41.303]     ...future.result$finished <- base::Sys.time()
[17:29:41.303]     ...future.result
[17:29:41.303] }
[17:29:41.308] assign_globals() ...
[17:29:41.308] List of 1
[17:29:41.308]  $ x: int [1:4] 0 1 2 3
[17:29:41.308]  - attr(*, "where")=List of 1
[17:29:41.308]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.308]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.308]  - attr(*, "resolved")= logi FALSE
[17:29:41.308]  - attr(*, "total_size")= int 133
[17:29:41.308]  - attr(*, "already-done")= logi TRUE
[17:29:41.316] - copied 'x' to environment
[17:29:41.316] assign_globals() ... done
[17:29:41.317] plan(): Setting new future strategy stack:
[17:29:41.317] List of future strategies:
[17:29:41.317] 1. sequential:
[17:29:41.317]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.317]    - tweaked: FALSE
[17:29:41.317]    - call: NULL
[17:29:41.319] plan(): nbrOfWorkers() = 1
[17:29:41.320] plan(): Setting new future strategy stack:
[17:29:41.321] List of future strategies:
[17:29:41.321] 1. sequential:
[17:29:41.321]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.321]    - tweaked: FALSE
[17:29:41.321]    - call: plan(strategy)
[17:29:41.322] plan(): nbrOfWorkers() = 1
[17:29:41.322] SequentialFuture started (and completed)
[17:29:41.322] - Launch lazy future ... done
[17:29:41.323] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_4-744727'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add7513b18
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.324] resolve() on list ...
[17:29:41.325]  recursive: 0
[17:29:41.325]  length: 4
[17:29:41.325] 
[17:29:41.325] resolved() for 'SequentialFuture' ...
[17:29:41.326] - state: 'finished'
[17:29:41.326] - run: TRUE
[17:29:41.326] - result: 'FutureResult'
[17:29:41.326] resolved() for 'SequentialFuture' ... done
[17:29:41.327] Future #1
[17:29:41.328] signalConditionsASAP(SequentialFuture, pos=1) ...
[17:29:41.328] - nx: 4
[17:29:41.328] - relay: TRUE
[17:29:41.328] - stdout: TRUE
[17:29:41.329] - signal: TRUE
[17:29:41.329] - resignal: FALSE
[17:29:41.329] - force: TRUE
[17:29:41.329] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:41.330] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:41.330]  - until=1
[17:29:41.330]  - relaying element #1
[17:29:41.330] signalConditions() ...
[17:29:41.331]  - include = 'immediateCondition'
[17:29:41.331]  - exclude = 
[17:29:41.331]  - resignal = FALSE
[17:29:41.332]  - Number of conditions: 1
[17:29:41.332] signalConditions() ... done
[17:29:41.332] signalConditions() ...
[17:29:41.332]  - include = 'immediateCondition'
[17:29:41.333]  - exclude = 
[17:29:41.333]  - resignal = FALSE
[17:29:41.333]  - Number of conditions: 1
[17:29:41.334] signalConditions() ... done
[17:29:41.334] signalConditions() ...
[17:29:41.335]  - include = 'condition'
[17:29:41.335]  - exclude = 'immediateCondition'
[17:29:41.335]  - resignal = TRUE
[17:29:41.335]  - Number of conditions: 1
[17:29:41.336]  - Condition #1: 'RngFutureWarning', 'FutureWarning', 'warning', 'RngFutureCondition', 'FutureCondition', 'condition'
[17:29:41.336] signalConditions() ... done
[17:29:41.337] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:41.337] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:41.337] signalConditionsASAP(SequentialFuture, pos=1) ... done
<RngFutureWarning: UNRELIABLE VALUE: Future ('fsample_1-757701') 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: a3dabee7-5a3d-99e4-8c8b-18e18336dd85


DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
SequentialFuture:
Label: 'fsample_1-757701'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add7513b18
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Conditions captured: [n=1] 'RngFutureWarning'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'

DEBUG: END TROUBLESHOOTING HELP
[17:29:41.341] getGlobalsAndPackages() ...
[17:29:41.341] Searching for globals...
[17:29:41.343] - globals found: [3] '{', 'sample', 'x'
[17:29:41.344] Searching for globals ... DONE
[17:29:41.344] Resolving globals: FALSE
[17:29:41.345] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.346] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.346] - globals: [1] 'x'
[17:29:41.346] 
[17:29:41.347] getGlobalsAndPackages() ... DONE
[17:29:41.349] run() for 'Future' ...
[17:29:41.350] - state: 'created'
[17:29:41.350] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.351] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.351] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.352]   - Field: 'label'
[17:29:41.352]   - Field: 'local'
[17:29:41.352]   - Field: 'owner'
[17:29:41.353]   - Field: 'envir'
[17:29:41.353]   - Field: 'packages'
[17:29:41.353]   - Field: 'gc'
[17:29:41.354]   - Field: 'conditions'
[17:29:41.354]   - Field: 'expr'
[17:29:41.354]   - Field: 'uuid'
[17:29:41.355]   - Field: 'seed'
[17:29:41.355]   - Field: 'version'
[17:29:41.355]   - Field: 'result'
[17:29:41.356]   - Field: 'asynchronous'
[17:29:41.356]   - Field: 'calls'
[17:29:41.356]   - Field: 'globals'
[17:29:41.357]   - Field: 'stdout'
[17:29:41.357]   - Field: 'earlySignal'
[17:29:41.357]   - Field: 'lazy'
[17:29:41.357]   - Field: 'state'
[17:29:41.358] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.358] - Launch lazy future ...
[17:29:41.359] Packages needed by the future expression (n = 0): <none>
[17:29:41.359] Packages needed by future strategies (n = 0): <none>
[17:29:41.360] {
[17:29:41.360]     {
[17:29:41.360]         {
[17:29:41.360]             ...future.startTime <- base::Sys.time()
[17:29:41.360]             {
[17:29:41.360]                 {
[17:29:41.360]                   {
[17:29:41.360]                     base::local({
[17:29:41.360]                       has_future <- base::requireNamespace("future", 
[17:29:41.360]                         quietly = TRUE)
[17:29:41.360]                       if (has_future) {
[17:29:41.360]                         ns <- base::getNamespace("future")
[17:29:41.360]                         version <- ns[[".package"]][["version"]]
[17:29:41.360]                         if (is.null(version)) 
[17:29:41.360]                           version <- utils::packageVersion("future")
[17:29:41.360]                       }
[17:29:41.360]                       else {
[17:29:41.360]                         version <- NULL
[17:29:41.360]                       }
[17:29:41.360]                       if (!has_future || version < "1.8.0") {
[17:29:41.360]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.360]                           "", base::R.version$version.string), 
[17:29:41.360]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.360]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.360]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.360]                             "release", "version")], collapse = " "), 
[17:29:41.360]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.360]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.360]                           info)
[17:29:41.360]                         info <- base::paste(info, collapse = "; ")
[17:29:41.360]                         if (!has_future) {
[17:29:41.360]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.360]                             info)
[17:29:41.360]                         }
[17:29:41.360]                         else {
[17:29:41.360]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.360]                             info, version)
[17:29:41.360]                         }
[17:29:41.360]                         base::stop(msg)
[17:29:41.360]                       }
[17:29:41.360]                     })
[17:29:41.360]                   }
[17:29:41.360]                   ...future.strategy.old <- future::plan("list")
[17:29:41.360]                   options(future.plan = NULL)
[17:29:41.360]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.360]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.360]                 }
[17:29:41.360]                 ...future.workdir <- getwd()
[17:29:41.360]             }
[17:29:41.360]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.360]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.360]         }
[17:29:41.360]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.360]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.360]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.360]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.360]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.360]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.360]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.360]             base::names(...future.oldOptions))
[17:29:41.360]     }
[17:29:41.360]     if (FALSE) {
[17:29:41.360]     }
[17:29:41.360]     else {
[17:29:41.360]         if (TRUE) {
[17:29:41.360]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.360]                 open = "w")
[17:29:41.360]         }
[17:29:41.360]         else {
[17:29:41.360]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.360]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.360]         }
[17:29:41.360]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.360]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.360]             base::sink(type = "output", split = FALSE)
[17:29:41.360]             base::close(...future.stdout)
[17:29:41.360]         }, add = TRUE)
[17:29:41.360]     }
[17:29:41.360]     ...future.frame <- base::sys.nframe()
[17:29:41.360]     ...future.conditions <- base::list()
[17:29:41.360]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.360]     if (FALSE) {
[17:29:41.360]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.360]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.360]     }
[17:29:41.360]     ...future.result <- base::tryCatch({
[17:29:41.360]         base::withCallingHandlers({
[17:29:41.360]             ...future.value <- base::withVisible(base::local({
[17:29:41.360]                 sample(x, size = 1L)
[17:29:41.360]             }))
[17:29:41.360]             future::FutureResult(value = ...future.value$value, 
[17:29:41.360]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.360]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.360]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.360]                     ...future.globalenv.names))
[17:29:41.360]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.360]         }, condition = base::local({
[17:29:41.360]             c <- base::c
[17:29:41.360]             inherits <- base::inherits
[17:29:41.360]             invokeRestart <- base::invokeRestart
[17:29:41.360]             length <- base::length
[17:29:41.360]             list <- base::list
[17:29:41.360]             seq.int <- base::seq.int
[17:29:41.360]             signalCondition <- base::signalCondition
[17:29:41.360]             sys.calls <- base::sys.calls
[17:29:41.360]             `[[` <- base::`[[`
[17:29:41.360]             `+` <- base::`+`
[17:29:41.360]             `<<-` <- base::`<<-`
[17:29:41.360]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.360]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.360]                   3L)]
[17:29:41.360]             }
[17:29:41.360]             function(cond) {
[17:29:41.360]                 is_error <- inherits(cond, "error")
[17:29:41.360]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.360]                   NULL)
[17:29:41.360]                 if (is_error) {
[17:29:41.360]                   sessionInformation <- function() {
[17:29:41.360]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.360]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.360]                       search = base::search(), system = base::Sys.info())
[17:29:41.360]                   }
[17:29:41.360]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.360]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.360]                     cond$call), session = sessionInformation(), 
[17:29:41.360]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.360]                   signalCondition(cond)
[17:29:41.360]                 }
[17:29:41.360]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.360]                 "immediateCondition"))) {
[17:29:41.360]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.360]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.360]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.360]                   if (TRUE && !signal) {
[17:29:41.360]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.360]                     {
[17:29:41.360]                       inherits <- base::inherits
[17:29:41.360]                       invokeRestart <- base::invokeRestart
[17:29:41.360]                       is.null <- base::is.null
[17:29:41.360]                       muffled <- FALSE
[17:29:41.360]                       if (inherits(cond, "message")) {
[17:29:41.360]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.360]                         if (muffled) 
[17:29:41.360]                           invokeRestart("muffleMessage")
[17:29:41.360]                       }
[17:29:41.360]                       else if (inherits(cond, "warning")) {
[17:29:41.360]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.360]                         if (muffled) 
[17:29:41.360]                           invokeRestart("muffleWarning")
[17:29:41.360]                       }
[17:29:41.360]                       else if (inherits(cond, "condition")) {
[17:29:41.360]                         if (!is.null(pattern)) {
[17:29:41.360]                           computeRestarts <- base::computeRestarts
[17:29:41.360]                           grepl <- base::grepl
[17:29:41.360]                           restarts <- computeRestarts(cond)
[17:29:41.360]                           for (restart in restarts) {
[17:29:41.360]                             name <- restart$name
[17:29:41.360]                             if (is.null(name)) 
[17:29:41.360]                               next
[17:29:41.360]                             if (!grepl(pattern, name)) 
[17:29:41.360]                               next
[17:29:41.360]                             invokeRestart(restart)
[17:29:41.360]                             muffled <- TRUE
[17:29:41.360]                             break
[17:29:41.360]                           }
[17:29:41.360]                         }
[17:29:41.360]                       }
[17:29:41.360]                       invisible(muffled)
[17:29:41.360]                     }
[17:29:41.360]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.360]                   }
[17:29:41.360]                 }
[17:29:41.360]                 else {
[17:29:41.360]                   if (TRUE) {
[17:29:41.360]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.360]                     {
[17:29:41.360]                       inherits <- base::inherits
[17:29:41.360]                       invokeRestart <- base::invokeRestart
[17:29:41.360]                       is.null <- base::is.null
[17:29:41.360]                       muffled <- FALSE
[17:29:41.360]                       if (inherits(cond, "message")) {
[17:29:41.360]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.360]                         if (muffled) 
[17:29:41.360]                           invokeRestart("muffleMessage")
[17:29:41.360]                       }
[17:29:41.360]                       else if (inherits(cond, "warning")) {
[17:29:41.360]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.360]                         if (muffled) 
[17:29:41.360]                           invokeRestart("muffleWarning")
[17:29:41.360]                       }
[17:29:41.360]                       else if (inherits(cond, "condition")) {
[17:29:41.360]                         if (!is.null(pattern)) {
[17:29:41.360]                           computeRestarts <- base::computeRestarts
[17:29:41.360]                           grepl <- base::grepl
[17:29:41.360]                           restarts <- computeRestarts(cond)
[17:29:41.360]                           for (restart in restarts) {
[17:29:41.360]                             name <- restart$name
[17:29:41.360]                             if (is.null(name)) 
[17:29:41.360]                               next
[17:29:41.360]                             if (!grepl(pattern, name)) 
[17:29:41.360]                               next
[17:29:41.360]                             invokeRestart(restart)
[17:29:41.360]                             muffled <- TRUE
[17:29:41.360]                             break
[17:29:41.360]                           }
[17:29:41.360]                         }
[17:29:41.360]                       }
[17:29:41.360]                       invisible(muffled)
[17:29:41.360]                     }
[17:29:41.360]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.360]                   }
[17:29:41.360]                 }
[17:29:41.360]             }
[17:29:41.360]         }))
[17:29:41.360]     }, error = function(ex) {
[17:29:41.360]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.360]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.360]                 ...future.rng), started = ...future.startTime, 
[17:29:41.360]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.360]             version = "1.8"), class = "FutureResult")
[17:29:41.360]     }, finally = {
[17:29:41.360]         if (!identical(...future.workdir, getwd())) 
[17:29:41.360]             setwd(...future.workdir)
[17:29:41.360]         {
[17:29:41.360]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.360]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.360]             }
[17:29:41.360]             base::options(...future.oldOptions)
[17:29:41.360]             if (.Platform$OS.type == "windows") {
[17:29:41.360]                 old_names <- names(...future.oldEnvVars)
[17:29:41.360]                 envs <- base::Sys.getenv()
[17:29:41.360]                 names <- names(envs)
[17:29:41.360]                 common <- intersect(names, old_names)
[17:29:41.360]                 added <- setdiff(names, old_names)
[17:29:41.360]                 removed <- setdiff(old_names, names)
[17:29:41.360]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.360]                   envs[common]]
[17:29:41.360]                 NAMES <- toupper(changed)
[17:29:41.360]                 args <- list()
[17:29:41.360]                 for (kk in seq_along(NAMES)) {
[17:29:41.360]                   name <- changed[[kk]]
[17:29:41.360]                   NAME <- NAMES[[kk]]
[17:29:41.360]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.360]                     next
[17:29:41.360]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.360]                 }
[17:29:41.360]                 NAMES <- toupper(added)
[17:29:41.360]                 for (kk in seq_along(NAMES)) {
[17:29:41.360]                   name <- added[[kk]]
[17:29:41.360]                   NAME <- NAMES[[kk]]
[17:29:41.360]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.360]                     next
[17:29:41.360]                   args[[name]] <- ""
[17:29:41.360]                 }
[17:29:41.360]                 NAMES <- toupper(removed)
[17:29:41.360]                 for (kk in seq_along(NAMES)) {
[17:29:41.360]                   name <- removed[[kk]]
[17:29:41.360]                   NAME <- NAMES[[kk]]
[17:29:41.360]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.360]                     next
[17:29:41.360]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.360]                 }
[17:29:41.360]                 if (length(args) > 0) 
[17:29:41.360]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.360]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.360]             }
[17:29:41.360]             else {
[17:29:41.360]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.360]             }
[17:29:41.360]             {
[17:29:41.360]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.360]                   0L) {
[17:29:41.360]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.360]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.360]                   base::options(opts)
[17:29:41.360]                 }
[17:29:41.360]                 {
[17:29:41.360]                   {
[17:29:41.360]                     base::assign(".Random.seed", c(10407L, -1950082174L, 
[17:29:41.360]                     -1301753524L, -1463922712L, 943607073L, 1021273868L, 
[17:29:41.360]                     -265366594L), envir = base::globalenv(), 
[17:29:41.360]                       inherits = FALSE)
[17:29:41.360]                     NULL
[17:29:41.360]                   }
[17:29:41.360]                   options(future.plan = NULL)
[17:29:41.360]                   if (is.na(NA_character_)) 
[17:29:41.360]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.360]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.360]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.360]                     .init = FALSE)
[17:29:41.360]                 }
[17:29:41.360]             }
[17:29:41.360]         }
[17:29:41.360]     })
[17:29:41.360]     if (TRUE) {
[17:29:41.360]         base::sink(type = "output", split = FALSE)
[17:29:41.360]         if (TRUE) {
[17:29:41.360]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.360]         }
[17:29:41.360]         else {
[17:29:41.360]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.360]         }
[17:29:41.360]         base::close(...future.stdout)
[17:29:41.360]         ...future.stdout <- NULL
[17:29:41.360]     }
[17:29:41.360]     ...future.result$conditions <- ...future.conditions
[17:29:41.360]     ...future.result$finished <- base::Sys.time()
[17:29:41.360]     ...future.result
[17:29:41.360] }
[17:29:41.366] assign_globals() ...
[17:29:41.367] List of 1
[17:29:41.367]  $ x: int [1:4] 0 1 2 3
[17:29:41.367]  - attr(*, "where")=List of 1
[17:29:41.367]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.367]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.367]  - attr(*, "resolved")= logi FALSE
[17:29:41.367]  - attr(*, "total_size")= int 133
[17:29:41.367]  - attr(*, "already-done")= logi TRUE
[17:29:41.372] - copied 'x' to environment
[17:29:41.372] assign_globals() ... done
[17:29:41.373] plan(): Setting new future strategy stack:
[17:29:41.373] List of future strategies:
[17:29:41.373] 1. sequential:
[17:29:41.373]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.373]    - tweaked: FALSE
[17:29:41.373]    - call: NULL
[17:29:41.374] plan(): nbrOfWorkers() = 1
[17:29:41.376] plan(): Setting new future strategy stack:
[17:29:41.377] List of future strategies:
[17:29:41.377] 1. sequential:
[17:29:41.377]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.377]    - tweaked: FALSE
[17:29:41.377]    - call: plan(strategy)
[17:29:41.380] plan(): nbrOfWorkers() = 1
[17:29:41.381] SequentialFuture started (and completed)
[17:29:41.381] - Launch lazy future ... done
[17:29:41.382] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_1-637072'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add5f7e920
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.383] getGlobalsAndPackages() ...
[17:29:41.384] Searching for globals...
[17:29:41.386] - globals found: [3] '{', 'sample', 'x'
[17:29:41.386] Searching for globals ... DONE
[17:29:41.386] Resolving globals: FALSE
[17:29:41.387] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.388] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.388] - globals: [1] 'x'
[17:29:41.389] 
[17:29:41.389] getGlobalsAndPackages() ... DONE
[17:29:41.389] run() for 'Future' ...
[17:29:41.390] - state: 'created'
[17:29:41.390] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.391] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.391] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.391]   - Field: 'label'
[17:29:41.391]   - Field: 'local'
[17:29:41.392]   - Field: 'owner'
[17:29:41.392]   - Field: 'envir'
[17:29:41.392]   - Field: 'packages'
[17:29:41.392]   - Field: 'gc'
[17:29:41.393]   - Field: 'conditions'
[17:29:41.393]   - Field: 'expr'
[17:29:41.393]   - Field: 'uuid'
[17:29:41.394]   - Field: 'seed'
[17:29:41.394]   - Field: 'version'
[17:29:41.394]   - Field: 'result'
[17:29:41.395]   - Field: 'asynchronous'
[17:29:41.395]   - Field: 'calls'
[17:29:41.395]   - Field: 'globals'
[17:29:41.395]   - Field: 'stdout'
[17:29:41.396]   - Field: 'earlySignal'
[17:29:41.396]   - Field: 'lazy'
[17:29:41.396]   - Field: 'state'
[17:29:41.397] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.397] - Launch lazy future ...
[17:29:41.397] Packages needed by the future expression (n = 0): <none>
[17:29:41.398] Packages needed by future strategies (n = 0): <none>
[17:29:41.398] {
[17:29:41.398]     {
[17:29:41.398]         {
[17:29:41.398]             ...future.startTime <- base::Sys.time()
[17:29:41.398]             {
[17:29:41.398]                 {
[17:29:41.398]                   {
[17:29:41.398]                     base::local({
[17:29:41.398]                       has_future <- base::requireNamespace("future", 
[17:29:41.398]                         quietly = TRUE)
[17:29:41.398]                       if (has_future) {
[17:29:41.398]                         ns <- base::getNamespace("future")
[17:29:41.398]                         version <- ns[[".package"]][["version"]]
[17:29:41.398]                         if (is.null(version)) 
[17:29:41.398]                           version <- utils::packageVersion("future")
[17:29:41.398]                       }
[17:29:41.398]                       else {
[17:29:41.398]                         version <- NULL
[17:29:41.398]                       }
[17:29:41.398]                       if (!has_future || version < "1.8.0") {
[17:29:41.398]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.398]                           "", base::R.version$version.string), 
[17:29:41.398]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.398]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.398]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.398]                             "release", "version")], collapse = " "), 
[17:29:41.398]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.398]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.398]                           info)
[17:29:41.398]                         info <- base::paste(info, collapse = "; ")
[17:29:41.398]                         if (!has_future) {
[17:29:41.398]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.398]                             info)
[17:29:41.398]                         }
[17:29:41.398]                         else {
[17:29:41.398]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.398]                             info, version)
[17:29:41.398]                         }
[17:29:41.398]                         base::stop(msg)
[17:29:41.398]                       }
[17:29:41.398]                     })
[17:29:41.398]                   }
[17:29:41.398]                   ...future.strategy.old <- future::plan("list")
[17:29:41.398]                   options(future.plan = NULL)
[17:29:41.398]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.398]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.398]                 }
[17:29:41.398]                 ...future.workdir <- getwd()
[17:29:41.398]             }
[17:29:41.398]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.398]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.398]         }
[17:29:41.398]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.398]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.398]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.398]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.398]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.398]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.398]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.398]             base::names(...future.oldOptions))
[17:29:41.398]     }
[17:29:41.398]     if (FALSE) {
[17:29:41.398]     }
[17:29:41.398]     else {
[17:29:41.398]         if (TRUE) {
[17:29:41.398]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.398]                 open = "w")
[17:29:41.398]         }
[17:29:41.398]         else {
[17:29:41.398]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.398]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.398]         }
[17:29:41.398]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.398]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.398]             base::sink(type = "output", split = FALSE)
[17:29:41.398]             base::close(...future.stdout)
[17:29:41.398]         }, add = TRUE)
[17:29:41.398]     }
[17:29:41.398]     ...future.frame <- base::sys.nframe()
[17:29:41.398]     ...future.conditions <- base::list()
[17:29:41.398]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.398]     if (FALSE) {
[17:29:41.398]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.398]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.398]     }
[17:29:41.398]     ...future.result <- base::tryCatch({
[17:29:41.398]         base::withCallingHandlers({
[17:29:41.398]             ...future.value <- base::withVisible(base::local({
[17:29:41.398]                 sample(x, size = 1L)
[17:29:41.398]             }))
[17:29:41.398]             future::FutureResult(value = ...future.value$value, 
[17:29:41.398]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.398]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.398]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.398]                     ...future.globalenv.names))
[17:29:41.398]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.398]         }, condition = base::local({
[17:29:41.398]             c <- base::c
[17:29:41.398]             inherits <- base::inherits
[17:29:41.398]             invokeRestart <- base::invokeRestart
[17:29:41.398]             length <- base::length
[17:29:41.398]             list <- base::list
[17:29:41.398]             seq.int <- base::seq.int
[17:29:41.398]             signalCondition <- base::signalCondition
[17:29:41.398]             sys.calls <- base::sys.calls
[17:29:41.398]             `[[` <- base::`[[`
[17:29:41.398]             `+` <- base::`+`
[17:29:41.398]             `<<-` <- base::`<<-`
[17:29:41.398]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.398]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.398]                   3L)]
[17:29:41.398]             }
[17:29:41.398]             function(cond) {
[17:29:41.398]                 is_error <- inherits(cond, "error")
[17:29:41.398]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.398]                   NULL)
[17:29:41.398]                 if (is_error) {
[17:29:41.398]                   sessionInformation <- function() {
[17:29:41.398]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.398]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.398]                       search = base::search(), system = base::Sys.info())
[17:29:41.398]                   }
[17:29:41.398]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.398]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.398]                     cond$call), session = sessionInformation(), 
[17:29:41.398]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.398]                   signalCondition(cond)
[17:29:41.398]                 }
[17:29:41.398]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.398]                 "immediateCondition"))) {
[17:29:41.398]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.398]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.398]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.398]                   if (TRUE && !signal) {
[17:29:41.398]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.398]                     {
[17:29:41.398]                       inherits <- base::inherits
[17:29:41.398]                       invokeRestart <- base::invokeRestart
[17:29:41.398]                       is.null <- base::is.null
[17:29:41.398]                       muffled <- FALSE
[17:29:41.398]                       if (inherits(cond, "message")) {
[17:29:41.398]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.398]                         if (muffled) 
[17:29:41.398]                           invokeRestart("muffleMessage")
[17:29:41.398]                       }
[17:29:41.398]                       else if (inherits(cond, "warning")) {
[17:29:41.398]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.398]                         if (muffled) 
[17:29:41.398]                           invokeRestart("muffleWarning")
[17:29:41.398]                       }
[17:29:41.398]                       else if (inherits(cond, "condition")) {
[17:29:41.398]                         if (!is.null(pattern)) {
[17:29:41.398]                           computeRestarts <- base::computeRestarts
[17:29:41.398]                           grepl <- base::grepl
[17:29:41.398]                           restarts <- computeRestarts(cond)
[17:29:41.398]                           for (restart in restarts) {
[17:29:41.398]                             name <- restart$name
[17:29:41.398]                             if (is.null(name)) 
[17:29:41.398]                               next
[17:29:41.398]                             if (!grepl(pattern, name)) 
[17:29:41.398]                               next
[17:29:41.398]                             invokeRestart(restart)
[17:29:41.398]                             muffled <- TRUE
[17:29:41.398]                             break
[17:29:41.398]                           }
[17:29:41.398]                         }
[17:29:41.398]                       }
[17:29:41.398]                       invisible(muffled)
[17:29:41.398]                     }
[17:29:41.398]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.398]                   }
[17:29:41.398]                 }
[17:29:41.398]                 else {
[17:29:41.398]                   if (TRUE) {
[17:29:41.398]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.398]                     {
[17:29:41.398]                       inherits <- base::inherits
[17:29:41.398]                       invokeRestart <- base::invokeRestart
[17:29:41.398]                       is.null <- base::is.null
[17:29:41.398]                       muffled <- FALSE
[17:29:41.398]                       if (inherits(cond, "message")) {
[17:29:41.398]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.398]                         if (muffled) 
[17:29:41.398]                           invokeRestart("muffleMessage")
[17:29:41.398]                       }
[17:29:41.398]                       else if (inherits(cond, "warning")) {
[17:29:41.398]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.398]                         if (muffled) 
[17:29:41.398]                           invokeRestart("muffleWarning")
[17:29:41.398]                       }
[17:29:41.398]                       else if (inherits(cond, "condition")) {
[17:29:41.398]                         if (!is.null(pattern)) {
[17:29:41.398]                           computeRestarts <- base::computeRestarts
[17:29:41.398]                           grepl <- base::grepl
[17:29:41.398]                           restarts <- computeRestarts(cond)
[17:29:41.398]                           for (restart in restarts) {
[17:29:41.398]                             name <- restart$name
[17:29:41.398]                             if (is.null(name)) 
[17:29:41.398]                               next
[17:29:41.398]                             if (!grepl(pattern, name)) 
[17:29:41.398]                               next
[17:29:41.398]                             invokeRestart(restart)
[17:29:41.398]                             muffled <- TRUE
[17:29:41.398]                             break
[17:29:41.398]                           }
[17:29:41.398]                         }
[17:29:41.398]                       }
[17:29:41.398]                       invisible(muffled)
[17:29:41.398]                     }
[17:29:41.398]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.398]                   }
[17:29:41.398]                 }
[17:29:41.398]             }
[17:29:41.398]         }))
[17:29:41.398]     }, error = function(ex) {
[17:29:41.398]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.398]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.398]                 ...future.rng), started = ...future.startTime, 
[17:29:41.398]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.398]             version = "1.8"), class = "FutureResult")
[17:29:41.398]     }, finally = {
[17:29:41.398]         if (!identical(...future.workdir, getwd())) 
[17:29:41.398]             setwd(...future.workdir)
[17:29:41.398]         {
[17:29:41.398]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.398]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.398]             }
[17:29:41.398]             base::options(...future.oldOptions)
[17:29:41.398]             if (.Platform$OS.type == "windows") {
[17:29:41.398]                 old_names <- names(...future.oldEnvVars)
[17:29:41.398]                 envs <- base::Sys.getenv()
[17:29:41.398]                 names <- names(envs)
[17:29:41.398]                 common <- intersect(names, old_names)
[17:29:41.398]                 added <- setdiff(names, old_names)
[17:29:41.398]                 removed <- setdiff(old_names, names)
[17:29:41.398]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.398]                   envs[common]]
[17:29:41.398]                 NAMES <- toupper(changed)
[17:29:41.398]                 args <- list()
[17:29:41.398]                 for (kk in seq_along(NAMES)) {
[17:29:41.398]                   name <- changed[[kk]]
[17:29:41.398]                   NAME <- NAMES[[kk]]
[17:29:41.398]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.398]                     next
[17:29:41.398]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.398]                 }
[17:29:41.398]                 NAMES <- toupper(added)
[17:29:41.398]                 for (kk in seq_along(NAMES)) {
[17:29:41.398]                   name <- added[[kk]]
[17:29:41.398]                   NAME <- NAMES[[kk]]
[17:29:41.398]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.398]                     next
[17:29:41.398]                   args[[name]] <- ""
[17:29:41.398]                 }
[17:29:41.398]                 NAMES <- toupper(removed)
[17:29:41.398]                 for (kk in seq_along(NAMES)) {
[17:29:41.398]                   name <- removed[[kk]]
[17:29:41.398]                   NAME <- NAMES[[kk]]
[17:29:41.398]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.398]                     next
[17:29:41.398]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.398]                 }
[17:29:41.398]                 if (length(args) > 0) 
[17:29:41.398]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.398]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.398]             }
[17:29:41.398]             else {
[17:29:41.398]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.398]             }
[17:29:41.398]             {
[17:29:41.398]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.398]                   0L) {
[17:29:41.398]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.398]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.398]                   base::options(opts)
[17:29:41.398]                 }
[17:29:41.398]                 {
[17:29:41.398]                   {
[17:29:41.398]                     base::assign(".Random.seed", c(10407L, -1463922712L, 
[17:29:41.398]                     -1482659767L, 1341507001L, -265366594L, -41790711L, 
[17:29:41.398]                     1571014043L), envir = base::globalenv(), 
[17:29:41.398]                       inherits = FALSE)
[17:29:41.398]                     NULL
[17:29:41.398]                   }
[17:29:41.398]                   options(future.plan = NULL)
[17:29:41.398]                   if (is.na(NA_character_)) 
[17:29:41.398]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.398]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.398]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.398]                     .init = FALSE)
[17:29:41.398]                 }
[17:29:41.398]             }
[17:29:41.398]         }
[17:29:41.398]     })
[17:29:41.398]     if (TRUE) {
[17:29:41.398]         base::sink(type = "output", split = FALSE)
[17:29:41.398]         if (TRUE) {
[17:29:41.398]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.398]         }
[17:29:41.398]         else {
[17:29:41.398]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.398]         }
[17:29:41.398]         base::close(...future.stdout)
[17:29:41.398]         ...future.stdout <- NULL
[17:29:41.398]     }
[17:29:41.398]     ...future.result$conditions <- ...future.conditions
[17:29:41.398]     ...future.result$finished <- base::Sys.time()
[17:29:41.398]     ...future.result
[17:29:41.398] }
[17:29:41.404] assign_globals() ...
[17:29:41.404] List of 1
[17:29:41.404]  $ x: int [1:4] 0 1 2 3
[17:29:41.404]  - attr(*, "where")=List of 1
[17:29:41.404]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.404]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.404]  - attr(*, "resolved")= logi FALSE
[17:29:41.404]  - attr(*, "total_size")= int 133
[17:29:41.404]  - attr(*, "already-done")= logi TRUE
[17:29:41.408] - copied 'x' to environment
[17:29:41.408] assign_globals() ... done
[17:29:41.409] plan(): Setting new future strategy stack:
[17:29:41.409] List of future strategies:
[17:29:41.409] 1. sequential:
[17:29:41.409]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.409]    - tweaked: FALSE
[17:29:41.409]    - call: NULL
[17:29:41.410] plan(): nbrOfWorkers() = 1
[17:29:41.412] plan(): Setting new future strategy stack:
[17:29:41.412] List of future strategies:
[17:29:41.412] 1. sequential:
[17:29:41.412]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.412]    - tweaked: FALSE
[17:29:41.412]    - call: plan(strategy)
[17:29:41.413] plan(): nbrOfWorkers() = 1
[17:29:41.413] SequentialFuture started (and completed)
[17:29:41.413] - Launch lazy future ... done
[17:29:41.413] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_2-979539'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add5f7e920
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.414] getGlobalsAndPackages() ...
[17:29:41.415] Searching for globals...
[17:29:41.416] - globals found: [3] '{', 'sample', 'x'
[17:29:41.416] Searching for globals ... DONE
[17:29:41.416] Resolving globals: FALSE
[17:29:41.417] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.417] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.417] - globals: [1] 'x'
[17:29:41.417] 
[17:29:41.418] getGlobalsAndPackages() ... DONE
[17:29:41.418] run() for 'Future' ...
[17:29:41.418] - state: 'created'
[17:29:41.418] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.419] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.419] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.419]   - Field: 'label'
[17:29:41.419]   - Field: 'local'
[17:29:41.419]   - Field: 'owner'
[17:29:41.420]   - Field: 'envir'
[17:29:41.420]   - Field: 'packages'
[17:29:41.420]   - Field: 'gc'
[17:29:41.420]   - Field: 'conditions'
[17:29:41.420]   - Field: 'expr'
[17:29:41.420]   - Field: 'uuid'
[17:29:41.421]   - Field: 'seed'
[17:29:41.421]   - Field: 'version'
[17:29:41.421]   - Field: 'result'
[17:29:41.421]   - Field: 'asynchronous'
[17:29:41.421]   - Field: 'calls'
[17:29:41.421]   - Field: 'globals'
[17:29:41.422]   - Field: 'stdout'
[17:29:41.422]   - Field: 'earlySignal'
[17:29:41.422]   - Field: 'lazy'
[17:29:41.422]   - Field: 'state'
[17:29:41.424] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.424] - Launch lazy future ...
[17:29:41.425] Packages needed by the future expression (n = 0): <none>
[17:29:41.425] Packages needed by future strategies (n = 0): <none>
[17:29:41.426] {
[17:29:41.426]     {
[17:29:41.426]         {
[17:29:41.426]             ...future.startTime <- base::Sys.time()
[17:29:41.426]             {
[17:29:41.426]                 {
[17:29:41.426]                   {
[17:29:41.426]                     base::local({
[17:29:41.426]                       has_future <- base::requireNamespace("future", 
[17:29:41.426]                         quietly = TRUE)
[17:29:41.426]                       if (has_future) {
[17:29:41.426]                         ns <- base::getNamespace("future")
[17:29:41.426]                         version <- ns[[".package"]][["version"]]
[17:29:41.426]                         if (is.null(version)) 
[17:29:41.426]                           version <- utils::packageVersion("future")
[17:29:41.426]                       }
[17:29:41.426]                       else {
[17:29:41.426]                         version <- NULL
[17:29:41.426]                       }
[17:29:41.426]                       if (!has_future || version < "1.8.0") {
[17:29:41.426]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.426]                           "", base::R.version$version.string), 
[17:29:41.426]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.426]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.426]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.426]                             "release", "version")], collapse = " "), 
[17:29:41.426]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.426]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.426]                           info)
[17:29:41.426]                         info <- base::paste(info, collapse = "; ")
[17:29:41.426]                         if (!has_future) {
[17:29:41.426]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.426]                             info)
[17:29:41.426]                         }
[17:29:41.426]                         else {
[17:29:41.426]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.426]                             info, version)
[17:29:41.426]                         }
[17:29:41.426]                         base::stop(msg)
[17:29:41.426]                       }
[17:29:41.426]                     })
[17:29:41.426]                   }
[17:29:41.426]                   ...future.strategy.old <- future::plan("list")
[17:29:41.426]                   options(future.plan = NULL)
[17:29:41.426]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.426]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.426]                 }
[17:29:41.426]                 ...future.workdir <- getwd()
[17:29:41.426]             }
[17:29:41.426]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.426]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.426]         }
[17:29:41.426]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.426]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.426]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.426]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.426]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.426]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.426]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.426]             base::names(...future.oldOptions))
[17:29:41.426]     }
[17:29:41.426]     if (FALSE) {
[17:29:41.426]     }
[17:29:41.426]     else {
[17:29:41.426]         if (TRUE) {
[17:29:41.426]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.426]                 open = "w")
[17:29:41.426]         }
[17:29:41.426]         else {
[17:29:41.426]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.426]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.426]         }
[17:29:41.426]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.426]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.426]             base::sink(type = "output", split = FALSE)
[17:29:41.426]             base::close(...future.stdout)
[17:29:41.426]         }, add = TRUE)
[17:29:41.426]     }
[17:29:41.426]     ...future.frame <- base::sys.nframe()
[17:29:41.426]     ...future.conditions <- base::list()
[17:29:41.426]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.426]     if (FALSE) {
[17:29:41.426]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.426]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.426]     }
[17:29:41.426]     ...future.result <- base::tryCatch({
[17:29:41.426]         base::withCallingHandlers({
[17:29:41.426]             ...future.value <- base::withVisible(base::local({
[17:29:41.426]                 sample(x, size = 1L)
[17:29:41.426]             }))
[17:29:41.426]             future::FutureResult(value = ...future.value$value, 
[17:29:41.426]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.426]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.426]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.426]                     ...future.globalenv.names))
[17:29:41.426]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.426]         }, condition = base::local({
[17:29:41.426]             c <- base::c
[17:29:41.426]             inherits <- base::inherits
[17:29:41.426]             invokeRestart <- base::invokeRestart
[17:29:41.426]             length <- base::length
[17:29:41.426]             list <- base::list
[17:29:41.426]             seq.int <- base::seq.int
[17:29:41.426]             signalCondition <- base::signalCondition
[17:29:41.426]             sys.calls <- base::sys.calls
[17:29:41.426]             `[[` <- base::`[[`
[17:29:41.426]             `+` <- base::`+`
[17:29:41.426]             `<<-` <- base::`<<-`
[17:29:41.426]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.426]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.426]                   3L)]
[17:29:41.426]             }
[17:29:41.426]             function(cond) {
[17:29:41.426]                 is_error <- inherits(cond, "error")
[17:29:41.426]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.426]                   NULL)
[17:29:41.426]                 if (is_error) {
[17:29:41.426]                   sessionInformation <- function() {
[17:29:41.426]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.426]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.426]                       search = base::search(), system = base::Sys.info())
[17:29:41.426]                   }
[17:29:41.426]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.426]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.426]                     cond$call), session = sessionInformation(), 
[17:29:41.426]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.426]                   signalCondition(cond)
[17:29:41.426]                 }
[17:29:41.426]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.426]                 "immediateCondition"))) {
[17:29:41.426]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.426]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.426]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.426]                   if (TRUE && !signal) {
[17:29:41.426]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.426]                     {
[17:29:41.426]                       inherits <- base::inherits
[17:29:41.426]                       invokeRestart <- base::invokeRestart
[17:29:41.426]                       is.null <- base::is.null
[17:29:41.426]                       muffled <- FALSE
[17:29:41.426]                       if (inherits(cond, "message")) {
[17:29:41.426]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.426]                         if (muffled) 
[17:29:41.426]                           invokeRestart("muffleMessage")
[17:29:41.426]                       }
[17:29:41.426]                       else if (inherits(cond, "warning")) {
[17:29:41.426]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.426]                         if (muffled) 
[17:29:41.426]                           invokeRestart("muffleWarning")
[17:29:41.426]                       }
[17:29:41.426]                       else if (inherits(cond, "condition")) {
[17:29:41.426]                         if (!is.null(pattern)) {
[17:29:41.426]                           computeRestarts <- base::computeRestarts
[17:29:41.426]                           grepl <- base::grepl
[17:29:41.426]                           restarts <- computeRestarts(cond)
[17:29:41.426]                           for (restart in restarts) {
[17:29:41.426]                             name <- restart$name
[17:29:41.426]                             if (is.null(name)) 
[17:29:41.426]                               next
[17:29:41.426]                             if (!grepl(pattern, name)) 
[17:29:41.426]                               next
[17:29:41.426]                             invokeRestart(restart)
[17:29:41.426]                             muffled <- TRUE
[17:29:41.426]                             break
[17:29:41.426]                           }
[17:29:41.426]                         }
[17:29:41.426]                       }
[17:29:41.426]                       invisible(muffled)
[17:29:41.426]                     }
[17:29:41.426]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.426]                   }
[17:29:41.426]                 }
[17:29:41.426]                 else {
[17:29:41.426]                   if (TRUE) {
[17:29:41.426]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.426]                     {
[17:29:41.426]                       inherits <- base::inherits
[17:29:41.426]                       invokeRestart <- base::invokeRestart
[17:29:41.426]                       is.null <- base::is.null
[17:29:41.426]                       muffled <- FALSE
[17:29:41.426]                       if (inherits(cond, "message")) {
[17:29:41.426]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.426]                         if (muffled) 
[17:29:41.426]                           invokeRestart("muffleMessage")
[17:29:41.426]                       }
[17:29:41.426]                       else if (inherits(cond, "warning")) {
[17:29:41.426]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.426]                         if (muffled) 
[17:29:41.426]                           invokeRestart("muffleWarning")
[17:29:41.426]                       }
[17:29:41.426]                       else if (inherits(cond, "condition")) {
[17:29:41.426]                         if (!is.null(pattern)) {
[17:29:41.426]                           computeRestarts <- base::computeRestarts
[17:29:41.426]                           grepl <- base::grepl
[17:29:41.426]                           restarts <- computeRestarts(cond)
[17:29:41.426]                           for (restart in restarts) {
[17:29:41.426]                             name <- restart$name
[17:29:41.426]                             if (is.null(name)) 
[17:29:41.426]                               next
[17:29:41.426]                             if (!grepl(pattern, name)) 
[17:29:41.426]                               next
[17:29:41.426]                             invokeRestart(restart)
[17:29:41.426]                             muffled <- TRUE
[17:29:41.426]                             break
[17:29:41.426]                           }
[17:29:41.426]                         }
[17:29:41.426]                       }
[17:29:41.426]                       invisible(muffled)
[17:29:41.426]                     }
[17:29:41.426]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.426]                   }
[17:29:41.426]                 }
[17:29:41.426]             }
[17:29:41.426]         }))
[17:29:41.426]     }, error = function(ex) {
[17:29:41.426]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.426]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.426]                 ...future.rng), started = ...future.startTime, 
[17:29:41.426]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.426]             version = "1.8"), class = "FutureResult")
[17:29:41.426]     }, finally = {
[17:29:41.426]         if (!identical(...future.workdir, getwd())) 
[17:29:41.426]             setwd(...future.workdir)
[17:29:41.426]         {
[17:29:41.426]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.426]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.426]             }
[17:29:41.426]             base::options(...future.oldOptions)
[17:29:41.426]             if (.Platform$OS.type == "windows") {
[17:29:41.426]                 old_names <- names(...future.oldEnvVars)
[17:29:41.426]                 envs <- base::Sys.getenv()
[17:29:41.426]                 names <- names(envs)
[17:29:41.426]                 common <- intersect(names, old_names)
[17:29:41.426]                 added <- setdiff(names, old_names)
[17:29:41.426]                 removed <- setdiff(old_names, names)
[17:29:41.426]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.426]                   envs[common]]
[17:29:41.426]                 NAMES <- toupper(changed)
[17:29:41.426]                 args <- list()
[17:29:41.426]                 for (kk in seq_along(NAMES)) {
[17:29:41.426]                   name <- changed[[kk]]
[17:29:41.426]                   NAME <- NAMES[[kk]]
[17:29:41.426]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.426]                     next
[17:29:41.426]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.426]                 }
[17:29:41.426]                 NAMES <- toupper(added)
[17:29:41.426]                 for (kk in seq_along(NAMES)) {
[17:29:41.426]                   name <- added[[kk]]
[17:29:41.426]                   NAME <- NAMES[[kk]]
[17:29:41.426]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.426]                     next
[17:29:41.426]                   args[[name]] <- ""
[17:29:41.426]                 }
[17:29:41.426]                 NAMES <- toupper(removed)
[17:29:41.426]                 for (kk in seq_along(NAMES)) {
[17:29:41.426]                   name <- removed[[kk]]
[17:29:41.426]                   NAME <- NAMES[[kk]]
[17:29:41.426]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.426]                     next
[17:29:41.426]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.426]                 }
[17:29:41.426]                 if (length(args) > 0) 
[17:29:41.426]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.426]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.426]             }
[17:29:41.426]             else {
[17:29:41.426]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.426]             }
[17:29:41.426]             {
[17:29:41.426]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.426]                   0L) {
[17:29:41.426]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.426]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.426]                   base::options(opts)
[17:29:41.426]                 }
[17:29:41.426]                 {
[17:29:41.426]                   {
[17:29:41.426]                     base::assign(".Random.seed", c(10407L, 1341507001L, 
[17:29:41.426]                     -1961694787L, 5022314L, 1571014043L, -1264788569L, 
[17:29:41.426]                     -798616520L), envir = base::globalenv(), 
[17:29:41.426]                       inherits = FALSE)
[17:29:41.426]                     NULL
[17:29:41.426]                   }
[17:29:41.426]                   options(future.plan = NULL)
[17:29:41.426]                   if (is.na(NA_character_)) 
[17:29:41.426]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.426]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.426]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.426]                     .init = FALSE)
[17:29:41.426]                 }
[17:29:41.426]             }
[17:29:41.426]         }
[17:29:41.426]     })
[17:29:41.426]     if (TRUE) {
[17:29:41.426]         base::sink(type = "output", split = FALSE)
[17:29:41.426]         if (TRUE) {
[17:29:41.426]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.426]         }
[17:29:41.426]         else {
[17:29:41.426]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.426]         }
[17:29:41.426]         base::close(...future.stdout)
[17:29:41.426]         ...future.stdout <- NULL
[17:29:41.426]     }
[17:29:41.426]     ...future.result$conditions <- ...future.conditions
[17:29:41.426]     ...future.result$finished <- base::Sys.time()
[17:29:41.426]     ...future.result
[17:29:41.426] }
[17:29:41.430] assign_globals() ...
[17:29:41.430] List of 1
[17:29:41.430]  $ x: int [1:4] 0 1 2 3
[17:29:41.430]  - attr(*, "where")=List of 1
[17:29:41.430]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.430]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.430]  - attr(*, "resolved")= logi FALSE
[17:29:41.430]  - attr(*, "total_size")= int 133
[17:29:41.430]  - attr(*, "already-done")= logi TRUE
[17:29:41.433] - copied 'x' to environment
[17:29:41.433] assign_globals() ... done
[17:29:41.434] plan(): Setting new future strategy stack:
[17:29:41.434] List of future strategies:
[17:29:41.434] 1. sequential:
[17:29:41.434]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.434]    - tweaked: FALSE
[17:29:41.434]    - call: NULL
[17:29:41.435] plan(): nbrOfWorkers() = 1
[17:29:41.437] plan(): Setting new future strategy stack:
[17:29:41.437] List of future strategies:
[17:29:41.437] 1. sequential:
[17:29:41.437]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.437]    - tweaked: FALSE
[17:29:41.437]    - call: plan(strategy)
[17:29:41.438] plan(): nbrOfWorkers() = 1
[17:29:41.439] SequentialFuture started (and completed)
[17:29:41.439] - Launch lazy future ... done
[17:29:41.439] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_3-405479'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add5f7e920
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.441] getGlobalsAndPackages() ...
[17:29:41.442] Searching for globals...
[17:29:41.443] - globals found: [3] '{', 'sample', 'x'
[17:29:41.443] Searching for globals ... DONE
[17:29:41.443] Resolving globals: FALSE
[17:29:41.444] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.444] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.445] - globals: [1] 'x'
[17:29:41.445] 
[17:29:41.445] getGlobalsAndPackages() ... DONE
[17:29:41.446] run() for 'Future' ...
[17:29:41.446] - state: 'created'
[17:29:41.446] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.446] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.447] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.447]   - Field: 'label'
[17:29:41.447]   - Field: 'local'
[17:29:41.447]   - Field: 'owner'
[17:29:41.447]   - Field: 'envir'
[17:29:41.448]   - Field: 'packages'
[17:29:41.448]   - Field: 'gc'
[17:29:41.448]   - Field: 'conditions'
[17:29:41.448]   - Field: 'expr'
[17:29:41.449]   - Field: 'uuid'
[17:29:41.449]   - Field: 'seed'
[17:29:41.449]   - Field: 'version'
[17:29:41.450]   - Field: 'result'
[17:29:41.450]   - Field: 'asynchronous'
[17:29:41.450]   - Field: 'calls'
[17:29:41.450]   - Field: 'globals'
[17:29:41.450]   - Field: 'stdout'
[17:29:41.451]   - Field: 'earlySignal'
[17:29:41.451]   - Field: 'lazy'
[17:29:41.451]   - Field: 'state'
[17:29:41.451] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.452] - Launch lazy future ...
[17:29:41.452] Packages needed by the future expression (n = 0): <none>
[17:29:41.452] Packages needed by future strategies (n = 0): <none>
[17:29:41.453] {
[17:29:41.453]     {
[17:29:41.453]         {
[17:29:41.453]             ...future.startTime <- base::Sys.time()
[17:29:41.453]             {
[17:29:41.453]                 {
[17:29:41.453]                   {
[17:29:41.453]                     base::local({
[17:29:41.453]                       has_future <- base::requireNamespace("future", 
[17:29:41.453]                         quietly = TRUE)
[17:29:41.453]                       if (has_future) {
[17:29:41.453]                         ns <- base::getNamespace("future")
[17:29:41.453]                         version <- ns[[".package"]][["version"]]
[17:29:41.453]                         if (is.null(version)) 
[17:29:41.453]                           version <- utils::packageVersion("future")
[17:29:41.453]                       }
[17:29:41.453]                       else {
[17:29:41.453]                         version <- NULL
[17:29:41.453]                       }
[17:29:41.453]                       if (!has_future || version < "1.8.0") {
[17:29:41.453]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.453]                           "", base::R.version$version.string), 
[17:29:41.453]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.453]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.453]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.453]                             "release", "version")], collapse = " "), 
[17:29:41.453]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.453]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.453]                           info)
[17:29:41.453]                         info <- base::paste(info, collapse = "; ")
[17:29:41.453]                         if (!has_future) {
[17:29:41.453]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.453]                             info)
[17:29:41.453]                         }
[17:29:41.453]                         else {
[17:29:41.453]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.453]                             info, version)
[17:29:41.453]                         }
[17:29:41.453]                         base::stop(msg)
[17:29:41.453]                       }
[17:29:41.453]                     })
[17:29:41.453]                   }
[17:29:41.453]                   ...future.strategy.old <- future::plan("list")
[17:29:41.453]                   options(future.plan = NULL)
[17:29:41.453]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.453]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.453]                 }
[17:29:41.453]                 ...future.workdir <- getwd()
[17:29:41.453]             }
[17:29:41.453]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.453]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.453]         }
[17:29:41.453]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.453]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.453]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.453]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.453]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.453]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.453]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.453]             base::names(...future.oldOptions))
[17:29:41.453]     }
[17:29:41.453]     if (FALSE) {
[17:29:41.453]     }
[17:29:41.453]     else {
[17:29:41.453]         if (TRUE) {
[17:29:41.453]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.453]                 open = "w")
[17:29:41.453]         }
[17:29:41.453]         else {
[17:29:41.453]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.453]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.453]         }
[17:29:41.453]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.453]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.453]             base::sink(type = "output", split = FALSE)
[17:29:41.453]             base::close(...future.stdout)
[17:29:41.453]         }, add = TRUE)
[17:29:41.453]     }
[17:29:41.453]     ...future.frame <- base::sys.nframe()
[17:29:41.453]     ...future.conditions <- base::list()
[17:29:41.453]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.453]     if (FALSE) {
[17:29:41.453]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.453]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.453]     }
[17:29:41.453]     ...future.result <- base::tryCatch({
[17:29:41.453]         base::withCallingHandlers({
[17:29:41.453]             ...future.value <- base::withVisible(base::local({
[17:29:41.453]                 sample(x, size = 1L)
[17:29:41.453]             }))
[17:29:41.453]             future::FutureResult(value = ...future.value$value, 
[17:29:41.453]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.453]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.453]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.453]                     ...future.globalenv.names))
[17:29:41.453]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.453]         }, condition = base::local({
[17:29:41.453]             c <- base::c
[17:29:41.453]             inherits <- base::inherits
[17:29:41.453]             invokeRestart <- base::invokeRestart
[17:29:41.453]             length <- base::length
[17:29:41.453]             list <- base::list
[17:29:41.453]             seq.int <- base::seq.int
[17:29:41.453]             signalCondition <- base::signalCondition
[17:29:41.453]             sys.calls <- base::sys.calls
[17:29:41.453]             `[[` <- base::`[[`
[17:29:41.453]             `+` <- base::`+`
[17:29:41.453]             `<<-` <- base::`<<-`
[17:29:41.453]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.453]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.453]                   3L)]
[17:29:41.453]             }
[17:29:41.453]             function(cond) {
[17:29:41.453]                 is_error <- inherits(cond, "error")
[17:29:41.453]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.453]                   NULL)
[17:29:41.453]                 if (is_error) {
[17:29:41.453]                   sessionInformation <- function() {
[17:29:41.453]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.453]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.453]                       search = base::search(), system = base::Sys.info())
[17:29:41.453]                   }
[17:29:41.453]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.453]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.453]                     cond$call), session = sessionInformation(), 
[17:29:41.453]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.453]                   signalCondition(cond)
[17:29:41.453]                 }
[17:29:41.453]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.453]                 "immediateCondition"))) {
[17:29:41.453]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.453]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.453]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.453]                   if (TRUE && !signal) {
[17:29:41.453]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.453]                     {
[17:29:41.453]                       inherits <- base::inherits
[17:29:41.453]                       invokeRestart <- base::invokeRestart
[17:29:41.453]                       is.null <- base::is.null
[17:29:41.453]                       muffled <- FALSE
[17:29:41.453]                       if (inherits(cond, "message")) {
[17:29:41.453]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.453]                         if (muffled) 
[17:29:41.453]                           invokeRestart("muffleMessage")
[17:29:41.453]                       }
[17:29:41.453]                       else if (inherits(cond, "warning")) {
[17:29:41.453]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.453]                         if (muffled) 
[17:29:41.453]                           invokeRestart("muffleWarning")
[17:29:41.453]                       }
[17:29:41.453]                       else if (inherits(cond, "condition")) {
[17:29:41.453]                         if (!is.null(pattern)) {
[17:29:41.453]                           computeRestarts <- base::computeRestarts
[17:29:41.453]                           grepl <- base::grepl
[17:29:41.453]                           restarts <- computeRestarts(cond)
[17:29:41.453]                           for (restart in restarts) {
[17:29:41.453]                             name <- restart$name
[17:29:41.453]                             if (is.null(name)) 
[17:29:41.453]                               next
[17:29:41.453]                             if (!grepl(pattern, name)) 
[17:29:41.453]                               next
[17:29:41.453]                             invokeRestart(restart)
[17:29:41.453]                             muffled <- TRUE
[17:29:41.453]                             break
[17:29:41.453]                           }
[17:29:41.453]                         }
[17:29:41.453]                       }
[17:29:41.453]                       invisible(muffled)
[17:29:41.453]                     }
[17:29:41.453]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.453]                   }
[17:29:41.453]                 }
[17:29:41.453]                 else {
[17:29:41.453]                   if (TRUE) {
[17:29:41.453]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.453]                     {
[17:29:41.453]                       inherits <- base::inherits
[17:29:41.453]                       invokeRestart <- base::invokeRestart
[17:29:41.453]                       is.null <- base::is.null
[17:29:41.453]                       muffled <- FALSE
[17:29:41.453]                       if (inherits(cond, "message")) {
[17:29:41.453]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.453]                         if (muffled) 
[17:29:41.453]                           invokeRestart("muffleMessage")
[17:29:41.453]                       }
[17:29:41.453]                       else if (inherits(cond, "warning")) {
[17:29:41.453]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.453]                         if (muffled) 
[17:29:41.453]                           invokeRestart("muffleWarning")
[17:29:41.453]                       }
[17:29:41.453]                       else if (inherits(cond, "condition")) {
[17:29:41.453]                         if (!is.null(pattern)) {
[17:29:41.453]                           computeRestarts <- base::computeRestarts
[17:29:41.453]                           grepl <- base::grepl
[17:29:41.453]                           restarts <- computeRestarts(cond)
[17:29:41.453]                           for (restart in restarts) {
[17:29:41.453]                             name <- restart$name
[17:29:41.453]                             if (is.null(name)) 
[17:29:41.453]                               next
[17:29:41.453]                             if (!grepl(pattern, name)) 
[17:29:41.453]                               next
[17:29:41.453]                             invokeRestart(restart)
[17:29:41.453]                             muffled <- TRUE
[17:29:41.453]                             break
[17:29:41.453]                           }
[17:29:41.453]                         }
[17:29:41.453]                       }
[17:29:41.453]                       invisible(muffled)
[17:29:41.453]                     }
[17:29:41.453]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.453]                   }
[17:29:41.453]                 }
[17:29:41.453]             }
[17:29:41.453]         }))
[17:29:41.453]     }, error = function(ex) {
[17:29:41.453]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.453]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.453]                 ...future.rng), started = ...future.startTime, 
[17:29:41.453]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.453]             version = "1.8"), class = "FutureResult")
[17:29:41.453]     }, finally = {
[17:29:41.453]         if (!identical(...future.workdir, getwd())) 
[17:29:41.453]             setwd(...future.workdir)
[17:29:41.453]         {
[17:29:41.453]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.453]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.453]             }
[17:29:41.453]             base::options(...future.oldOptions)
[17:29:41.453]             if (.Platform$OS.type == "windows") {
[17:29:41.453]                 old_names <- names(...future.oldEnvVars)
[17:29:41.453]                 envs <- base::Sys.getenv()
[17:29:41.453]                 names <- names(envs)
[17:29:41.453]                 common <- intersect(names, old_names)
[17:29:41.453]                 added <- setdiff(names, old_names)
[17:29:41.453]                 removed <- setdiff(old_names, names)
[17:29:41.453]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.453]                   envs[common]]
[17:29:41.453]                 NAMES <- toupper(changed)
[17:29:41.453]                 args <- list()
[17:29:41.453]                 for (kk in seq_along(NAMES)) {
[17:29:41.453]                   name <- changed[[kk]]
[17:29:41.453]                   NAME <- NAMES[[kk]]
[17:29:41.453]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.453]                     next
[17:29:41.453]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.453]                 }
[17:29:41.453]                 NAMES <- toupper(added)
[17:29:41.453]                 for (kk in seq_along(NAMES)) {
[17:29:41.453]                   name <- added[[kk]]
[17:29:41.453]                   NAME <- NAMES[[kk]]
[17:29:41.453]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.453]                     next
[17:29:41.453]                   args[[name]] <- ""
[17:29:41.453]                 }
[17:29:41.453]                 NAMES <- toupper(removed)
[17:29:41.453]                 for (kk in seq_along(NAMES)) {
[17:29:41.453]                   name <- removed[[kk]]
[17:29:41.453]                   NAME <- NAMES[[kk]]
[17:29:41.453]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.453]                     next
[17:29:41.453]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.453]                 }
[17:29:41.453]                 if (length(args) > 0) 
[17:29:41.453]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.453]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.453]             }
[17:29:41.453]             else {
[17:29:41.453]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.453]             }
[17:29:41.453]             {
[17:29:41.453]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.453]                   0L) {
[17:29:41.453]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.453]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.453]                   base::options(opts)
[17:29:41.453]                 }
[17:29:41.453]                 {
[17:29:41.453]                   {
[17:29:41.453]                     base::assign(".Random.seed", c(10407L, 5022314L, 
[17:29:41.453]                     797175219L, 1357813559L, -798616520L, -671125464L, 
[17:29:41.453]                     2060151254L), envir = base::globalenv(), 
[17:29:41.453]                       inherits = FALSE)
[17:29:41.453]                     NULL
[17:29:41.453]                   }
[17:29:41.453]                   options(future.plan = NULL)
[17:29:41.453]                   if (is.na(NA_character_)) 
[17:29:41.453]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.453]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.453]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.453]                     .init = FALSE)
[17:29:41.453]                 }
[17:29:41.453]             }
[17:29:41.453]         }
[17:29:41.453]     })
[17:29:41.453]     if (TRUE) {
[17:29:41.453]         base::sink(type = "output", split = FALSE)
[17:29:41.453]         if (TRUE) {
[17:29:41.453]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.453]         }
[17:29:41.453]         else {
[17:29:41.453]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.453]         }
[17:29:41.453]         base::close(...future.stdout)
[17:29:41.453]         ...future.stdout <- NULL
[17:29:41.453]     }
[17:29:41.453]     ...future.result$conditions <- ...future.conditions
[17:29:41.453]     ...future.result$finished <- base::Sys.time()
[17:29:41.453]     ...future.result
[17:29:41.453] }
[17:29:41.459] assign_globals() ...
[17:29:41.459] List of 1
[17:29:41.459]  $ x: int [1:4] 0 1 2 3
[17:29:41.459]  - attr(*, "where")=List of 1
[17:29:41.459]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.459]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.459]  - attr(*, "resolved")= logi FALSE
[17:29:41.459]  - attr(*, "total_size")= int 133
[17:29:41.459]  - attr(*, "already-done")= logi TRUE
[17:29:41.464] - copied 'x' to environment
[17:29:41.464] assign_globals() ... done
[17:29:41.465] plan(): Setting new future strategy stack:
[17:29:41.465] List of future strategies:
[17:29:41.465] 1. sequential:
[17:29:41.465]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.465]    - tweaked: FALSE
[17:29:41.465]    - call: NULL
[17:29:41.465] plan(): nbrOfWorkers() = 1
[17:29:41.467] plan(): Setting new future strategy stack:
[17:29:41.467] List of future strategies:
[17:29:41.467] 1. sequential:
[17:29:41.467]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.467]    - tweaked: FALSE
[17:29:41.467]    - call: plan(strategy)
[17:29:41.468] plan(): nbrOfWorkers() = 1
[17:29:41.468] SequentialFuture started (and completed)
[17:29:41.468] - Launch lazy future ... done
[17:29:41.469] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_4-316964'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add5f7e920
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.474] resolve() on list ...
[17:29:41.474]  recursive: 0
[17:29:41.474]  length: 4
[17:29:41.474] 
[17:29:41.475] resolved() for 'SequentialFuture' ...
[17:29:41.475] - state: 'finished'
[17:29:41.475] - run: TRUE
[17:29:41.476] - result: 'FutureResult'
[17:29:41.476] resolved() for 'SequentialFuture' ... done
[17:29:41.476] Future #1
[17:29:41.477] signalConditionsASAP(SequentialFuture, pos=1) ...
[17:29:41.477] - nx: 4
[17:29:41.477] - relay: TRUE
[17:29:41.478] - stdout: TRUE
[17:29:41.478] - signal: TRUE
[17:29:41.478] - resignal: FALSE
[17:29:41.478] - force: TRUE
[17:29:41.479] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:41.479] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:41.479]  - until=1
[17:29:41.479]  - relaying element #1
[17:29:41.480] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:41.480] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:41.480] signalConditionsASAP(SequentialFuture, pos=1) ... done
[17:29:41.480]  length: 3 (resolved future 1)
[17:29:41.481] resolved() for 'SequentialFuture' ...
[17:29:41.481] - state: 'finished'
[17:29:41.481] - run: TRUE
[17:29:41.481] - result: 'FutureResult'
[17:29:41.481] resolved() for 'SequentialFuture' ... done
[17:29:41.482] Future #2
[17:29:41.482] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:29:41.482] - nx: 4
[17:29:41.483] - relay: TRUE
[17:29:41.483] - stdout: TRUE
[17:29:41.483] - signal: TRUE
[17:29:41.483] - resignal: FALSE
[17:29:41.483] - force: TRUE
[17:29:41.483] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:41.484] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:41.484]  - until=2
[17:29:41.484]  - relaying element #2
[17:29:41.484] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:41.484] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:41.485] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:29:41.485]  length: 2 (resolved future 2)
[17:29:41.485] resolved() for 'SequentialFuture' ...
[17:29:41.485] - state: 'finished'
[17:29:41.486] - run: TRUE
[17:29:41.486] - result: 'FutureResult'
[17:29:41.486] resolved() for 'SequentialFuture' ... done
[17:29:41.486] Future #3
[17:29:41.487] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:29:41.487] - nx: 4
[17:29:41.487] - relay: TRUE
[17:29:41.487] - stdout: TRUE
[17:29:41.488] - signal: TRUE
[17:29:41.488] - resignal: FALSE
[17:29:41.488] - force: TRUE
[17:29:41.488] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:41.488] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:41.489]  - until=3
[17:29:41.489]  - relaying element #3
[17:29:41.489] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:41.489] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:41.489] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:29:41.490]  length: 1 (resolved future 3)
[17:29:41.490] resolved() for 'SequentialFuture' ...
[17:29:41.490] - state: 'finished'
[17:29:41.490] - run: TRUE
[17:29:41.490] - result: 'FutureResult'
[17:29:41.491] resolved() for 'SequentialFuture' ... done
[17:29:41.491] Future #4
[17:29:41.491] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:29:41.492] - nx: 4
[17:29:41.492] - relay: TRUE
[17:29:41.492] - stdout: TRUE
[17:29:41.492] - signal: TRUE
[17:29:41.493] - resignal: FALSE
[17:29:41.493] - force: TRUE
[17:29:41.493] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:41.493] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:41.493]  - until=4
[17:29:41.493]  - relaying element #4
[17:29:41.494] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:41.494] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:41.494] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:29:41.494]  length: 0 (resolved future 4)
[17:29:41.494] Relaying remaining futures
[17:29:41.495] signalConditionsASAP(NULL, pos=0) ...
[17:29:41.495] - nx: 4
[17:29:41.495] - relay: TRUE
[17:29:41.495] - stdout: TRUE
[17:29:41.495] - signal: TRUE
[17:29:41.495] - resignal: FALSE
[17:29:41.496] - force: TRUE
[17:29:41.496] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:41.496] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:29:41.496] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:41.496] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:41.496] signalConditionsASAP(NULL, pos=0) ... done
[17:29:41.497] resolve() on list ... DONE
[[1]]
[1] 2

[[2]]
[1] 2

[[3]]
[1] 0

[[4]]
[1] 3

[17:29:41.497] getGlobalsAndPackages() ...
[17:29:41.498] Searching for globals...
[17:29:41.499] - globals found: [3] '{', 'sample', 'x'
[17:29:41.499] Searching for globals ... DONE
[17:29:41.500] Resolving globals: FALSE
[17:29:41.500] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.501] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.501] - globals: [1] 'x'
[17:29:41.501] 
[17:29:41.502] getGlobalsAndPackages() ... DONE
[17:29:41.502] run() for 'Future' ...
[17:29:41.502] - state: 'created'
[17:29:41.502] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.503] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.503] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.503]   - Field: 'label'
[17:29:41.503]   - Field: 'local'
[17:29:41.504]   - Field: 'owner'
[17:29:41.504]   - Field: 'envir'
[17:29:41.504]   - Field: 'packages'
[17:29:41.504]   - Field: 'gc'
[17:29:41.504]   - Field: 'conditions'
[17:29:41.505]   - Field: 'expr'
[17:29:41.505]   - Field: 'uuid'
[17:29:41.505]   - Field: 'seed'
[17:29:41.505]   - Field: 'version'
[17:29:41.505]   - Field: 'result'
[17:29:41.506]   - Field: 'asynchronous'
[17:29:41.506]   - Field: 'calls'
[17:29:41.506]   - Field: 'globals'
[17:29:41.506]   - Field: 'stdout'
[17:29:41.506]   - Field: 'earlySignal'
[17:29:41.506]   - Field: 'lazy'
[17:29:41.507]   - Field: 'state'
[17:29:41.507] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.507] - Launch lazy future ...
[17:29:41.507] Packages needed by the future expression (n = 0): <none>
[17:29:41.507] Packages needed by future strategies (n = 0): <none>
[17:29:41.508] {
[17:29:41.508]     {
[17:29:41.508]         {
[17:29:41.508]             ...future.startTime <- base::Sys.time()
[17:29:41.508]             {
[17:29:41.508]                 {
[17:29:41.508]                   {
[17:29:41.508]                     base::local({
[17:29:41.508]                       has_future <- base::requireNamespace("future", 
[17:29:41.508]                         quietly = TRUE)
[17:29:41.508]                       if (has_future) {
[17:29:41.508]                         ns <- base::getNamespace("future")
[17:29:41.508]                         version <- ns[[".package"]][["version"]]
[17:29:41.508]                         if (is.null(version)) 
[17:29:41.508]                           version <- utils::packageVersion("future")
[17:29:41.508]                       }
[17:29:41.508]                       else {
[17:29:41.508]                         version <- NULL
[17:29:41.508]                       }
[17:29:41.508]                       if (!has_future || version < "1.8.0") {
[17:29:41.508]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.508]                           "", base::R.version$version.string), 
[17:29:41.508]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.508]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.508]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.508]                             "release", "version")], collapse = " "), 
[17:29:41.508]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.508]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.508]                           info)
[17:29:41.508]                         info <- base::paste(info, collapse = "; ")
[17:29:41.508]                         if (!has_future) {
[17:29:41.508]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.508]                             info)
[17:29:41.508]                         }
[17:29:41.508]                         else {
[17:29:41.508]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.508]                             info, version)
[17:29:41.508]                         }
[17:29:41.508]                         base::stop(msg)
[17:29:41.508]                       }
[17:29:41.508]                     })
[17:29:41.508]                   }
[17:29:41.508]                   ...future.strategy.old <- future::plan("list")
[17:29:41.508]                   options(future.plan = NULL)
[17:29:41.508]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.508]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.508]                 }
[17:29:41.508]                 ...future.workdir <- getwd()
[17:29:41.508]             }
[17:29:41.508]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.508]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.508]         }
[17:29:41.508]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.508]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.508]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.508]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.508]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.508]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.508]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.508]             base::names(...future.oldOptions))
[17:29:41.508]     }
[17:29:41.508]     if (FALSE) {
[17:29:41.508]     }
[17:29:41.508]     else {
[17:29:41.508]         if (TRUE) {
[17:29:41.508]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.508]                 open = "w")
[17:29:41.508]         }
[17:29:41.508]         else {
[17:29:41.508]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.508]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.508]         }
[17:29:41.508]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.508]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.508]             base::sink(type = "output", split = FALSE)
[17:29:41.508]             base::close(...future.stdout)
[17:29:41.508]         }, add = TRUE)
[17:29:41.508]     }
[17:29:41.508]     ...future.frame <- base::sys.nframe()
[17:29:41.508]     ...future.conditions <- base::list()
[17:29:41.508]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.508]     if (FALSE) {
[17:29:41.508]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.508]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.508]     }
[17:29:41.508]     ...future.result <- base::tryCatch({
[17:29:41.508]         base::withCallingHandlers({
[17:29:41.508]             ...future.value <- base::withVisible(base::local({
[17:29:41.508]                 sample(x, size = 1L)
[17:29:41.508]             }))
[17:29:41.508]             future::FutureResult(value = ...future.value$value, 
[17:29:41.508]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.508]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.508]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.508]                     ...future.globalenv.names))
[17:29:41.508]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.508]         }, condition = base::local({
[17:29:41.508]             c <- base::c
[17:29:41.508]             inherits <- base::inherits
[17:29:41.508]             invokeRestart <- base::invokeRestart
[17:29:41.508]             length <- base::length
[17:29:41.508]             list <- base::list
[17:29:41.508]             seq.int <- base::seq.int
[17:29:41.508]             signalCondition <- base::signalCondition
[17:29:41.508]             sys.calls <- base::sys.calls
[17:29:41.508]             `[[` <- base::`[[`
[17:29:41.508]             `+` <- base::`+`
[17:29:41.508]             `<<-` <- base::`<<-`
[17:29:41.508]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.508]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.508]                   3L)]
[17:29:41.508]             }
[17:29:41.508]             function(cond) {
[17:29:41.508]                 is_error <- inherits(cond, "error")
[17:29:41.508]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.508]                   NULL)
[17:29:41.508]                 if (is_error) {
[17:29:41.508]                   sessionInformation <- function() {
[17:29:41.508]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.508]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.508]                       search = base::search(), system = base::Sys.info())
[17:29:41.508]                   }
[17:29:41.508]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.508]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.508]                     cond$call), session = sessionInformation(), 
[17:29:41.508]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.508]                   signalCondition(cond)
[17:29:41.508]                 }
[17:29:41.508]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.508]                 "immediateCondition"))) {
[17:29:41.508]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.508]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.508]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.508]                   if (TRUE && !signal) {
[17:29:41.508]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.508]                     {
[17:29:41.508]                       inherits <- base::inherits
[17:29:41.508]                       invokeRestart <- base::invokeRestart
[17:29:41.508]                       is.null <- base::is.null
[17:29:41.508]                       muffled <- FALSE
[17:29:41.508]                       if (inherits(cond, "message")) {
[17:29:41.508]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.508]                         if (muffled) 
[17:29:41.508]                           invokeRestart("muffleMessage")
[17:29:41.508]                       }
[17:29:41.508]                       else if (inherits(cond, "warning")) {
[17:29:41.508]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.508]                         if (muffled) 
[17:29:41.508]                           invokeRestart("muffleWarning")
[17:29:41.508]                       }
[17:29:41.508]                       else if (inherits(cond, "condition")) {
[17:29:41.508]                         if (!is.null(pattern)) {
[17:29:41.508]                           computeRestarts <- base::computeRestarts
[17:29:41.508]                           grepl <- base::grepl
[17:29:41.508]                           restarts <- computeRestarts(cond)
[17:29:41.508]                           for (restart in restarts) {
[17:29:41.508]                             name <- restart$name
[17:29:41.508]                             if (is.null(name)) 
[17:29:41.508]                               next
[17:29:41.508]                             if (!grepl(pattern, name)) 
[17:29:41.508]                               next
[17:29:41.508]                             invokeRestart(restart)
[17:29:41.508]                             muffled <- TRUE
[17:29:41.508]                             break
[17:29:41.508]                           }
[17:29:41.508]                         }
[17:29:41.508]                       }
[17:29:41.508]                       invisible(muffled)
[17:29:41.508]                     }
[17:29:41.508]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.508]                   }
[17:29:41.508]                 }
[17:29:41.508]                 else {
[17:29:41.508]                   if (TRUE) {
[17:29:41.508]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.508]                     {
[17:29:41.508]                       inherits <- base::inherits
[17:29:41.508]                       invokeRestart <- base::invokeRestart
[17:29:41.508]                       is.null <- base::is.null
[17:29:41.508]                       muffled <- FALSE
[17:29:41.508]                       if (inherits(cond, "message")) {
[17:29:41.508]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.508]                         if (muffled) 
[17:29:41.508]                           invokeRestart("muffleMessage")
[17:29:41.508]                       }
[17:29:41.508]                       else if (inherits(cond, "warning")) {
[17:29:41.508]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.508]                         if (muffled) 
[17:29:41.508]                           invokeRestart("muffleWarning")
[17:29:41.508]                       }
[17:29:41.508]                       else if (inherits(cond, "condition")) {
[17:29:41.508]                         if (!is.null(pattern)) {
[17:29:41.508]                           computeRestarts <- base::computeRestarts
[17:29:41.508]                           grepl <- base::grepl
[17:29:41.508]                           restarts <- computeRestarts(cond)
[17:29:41.508]                           for (restart in restarts) {
[17:29:41.508]                             name <- restart$name
[17:29:41.508]                             if (is.null(name)) 
[17:29:41.508]                               next
[17:29:41.508]                             if (!grepl(pattern, name)) 
[17:29:41.508]                               next
[17:29:41.508]                             invokeRestart(restart)
[17:29:41.508]                             muffled <- TRUE
[17:29:41.508]                             break
[17:29:41.508]                           }
[17:29:41.508]                         }
[17:29:41.508]                       }
[17:29:41.508]                       invisible(muffled)
[17:29:41.508]                     }
[17:29:41.508]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.508]                   }
[17:29:41.508]                 }
[17:29:41.508]             }
[17:29:41.508]         }))
[17:29:41.508]     }, error = function(ex) {
[17:29:41.508]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.508]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.508]                 ...future.rng), started = ...future.startTime, 
[17:29:41.508]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.508]             version = "1.8"), class = "FutureResult")
[17:29:41.508]     }, finally = {
[17:29:41.508]         if (!identical(...future.workdir, getwd())) 
[17:29:41.508]             setwd(...future.workdir)
[17:29:41.508]         {
[17:29:41.508]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.508]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.508]             }
[17:29:41.508]             base::options(...future.oldOptions)
[17:29:41.508]             if (.Platform$OS.type == "windows") {
[17:29:41.508]                 old_names <- names(...future.oldEnvVars)
[17:29:41.508]                 envs <- base::Sys.getenv()
[17:29:41.508]                 names <- names(envs)
[17:29:41.508]                 common <- intersect(names, old_names)
[17:29:41.508]                 added <- setdiff(names, old_names)
[17:29:41.508]                 removed <- setdiff(old_names, names)
[17:29:41.508]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.508]                   envs[common]]
[17:29:41.508]                 NAMES <- toupper(changed)
[17:29:41.508]                 args <- list()
[17:29:41.508]                 for (kk in seq_along(NAMES)) {
[17:29:41.508]                   name <- changed[[kk]]
[17:29:41.508]                   NAME <- NAMES[[kk]]
[17:29:41.508]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.508]                     next
[17:29:41.508]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.508]                 }
[17:29:41.508]                 NAMES <- toupper(added)
[17:29:41.508]                 for (kk in seq_along(NAMES)) {
[17:29:41.508]                   name <- added[[kk]]
[17:29:41.508]                   NAME <- NAMES[[kk]]
[17:29:41.508]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.508]                     next
[17:29:41.508]                   args[[name]] <- ""
[17:29:41.508]                 }
[17:29:41.508]                 NAMES <- toupper(removed)
[17:29:41.508]                 for (kk in seq_along(NAMES)) {
[17:29:41.508]                   name <- removed[[kk]]
[17:29:41.508]                   NAME <- NAMES[[kk]]
[17:29:41.508]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.508]                     next
[17:29:41.508]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.508]                 }
[17:29:41.508]                 if (length(args) > 0) 
[17:29:41.508]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.508]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.508]             }
[17:29:41.508]             else {
[17:29:41.508]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.508]             }
[17:29:41.508]             {
[17:29:41.508]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.508]                   0L) {
[17:29:41.508]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.508]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.508]                   base::options(opts)
[17:29:41.508]                 }
[17:29:41.508]                 {
[17:29:41.508]                   {
[17:29:41.508]                     base::assign(".Random.seed", c(10407L, 1109576272L, 
[17:29:41.508]                     -1196620031L, 856904683L, -596522873L, -1403402474L, 
[17:29:41.508]                     -594096583L), envir = base::globalenv(), 
[17:29:41.508]                       inherits = FALSE)
[17:29:41.508]                     NULL
[17:29:41.508]                   }
[17:29:41.508]                   options(future.plan = NULL)
[17:29:41.508]                   if (is.na(NA_character_)) 
[17:29:41.508]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.508]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.508]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.508]                     .init = FALSE)
[17:29:41.508]                 }
[17:29:41.508]             }
[17:29:41.508]         }
[17:29:41.508]     })
[17:29:41.508]     if (TRUE) {
[17:29:41.508]         base::sink(type = "output", split = FALSE)
[17:29:41.508]         if (TRUE) {
[17:29:41.508]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.508]         }
[17:29:41.508]         else {
[17:29:41.508]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.508]         }
[17:29:41.508]         base::close(...future.stdout)
[17:29:41.508]         ...future.stdout <- NULL
[17:29:41.508]     }
[17:29:41.508]     ...future.result$conditions <- ...future.conditions
[17:29:41.508]     ...future.result$finished <- base::Sys.time()
[17:29:41.508]     ...future.result
[17:29:41.508] }
[17:29:41.512] assign_globals() ...
[17:29:41.512] List of 1
[17:29:41.512]  $ x: int [1:4] 0 1 2 3
[17:29:41.512]  - attr(*, "where")=List of 1
[17:29:41.512]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.512]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.512]  - attr(*, "resolved")= logi FALSE
[17:29:41.512]  - attr(*, "total_size")= int 133
[17:29:41.512]  - attr(*, "already-done")= logi TRUE
[17:29:41.518] - copied 'x' to environment
[17:29:41.518] assign_globals() ... done
[17:29:41.518] plan(): Setting new future strategy stack:
[17:29:41.519] List of future strategies:
[17:29:41.519] 1. sequential:
[17:29:41.519]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.519]    - tweaked: FALSE
[17:29:41.519]    - call: NULL
[17:29:41.519] plan(): nbrOfWorkers() = 1
[17:29:41.521] plan(): Setting new future strategy stack:
[17:29:41.521] List of future strategies:
[17:29:41.521] 1. sequential:
[17:29:41.521]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.521]    - tweaked: FALSE
[17:29:41.521]    - call: plan(strategy)
[17:29:41.521] plan(): nbrOfWorkers() = 1
[17:29:41.522] SequentialFuture started (and completed)
[17:29:41.522] - Launch lazy future ... done
[17:29:41.522] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_1-218749'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add7216ae8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.523] getGlobalsAndPackages() ...
[17:29:41.523] Searching for globals...
[17:29:41.525] - globals found: [3] '{', 'sample', 'x'
[17:29:41.525] Searching for globals ... DONE
[17:29:41.525] Resolving globals: FALSE
[17:29:41.526] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.526] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.526] - globals: [1] 'x'
[17:29:41.527] 
[17:29:41.527] getGlobalsAndPackages() ... DONE
[17:29:41.527] run() for 'Future' ...
[17:29:41.527] - state: 'created'
[17:29:41.527] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.528] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.528] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.528]   - Field: 'label'
[17:29:41.528]   - Field: 'local'
[17:29:41.529]   - Field: 'owner'
[17:29:41.529]   - Field: 'envir'
[17:29:41.529]   - Field: 'packages'
[17:29:41.529]   - Field: 'gc'
[17:29:41.529]   - Field: 'conditions'
[17:29:41.529]   - Field: 'expr'
[17:29:41.530]   - Field: 'uuid'
[17:29:41.530]   - Field: 'seed'
[17:29:41.530]   - Field: 'version'
[17:29:41.530]   - Field: 'result'
[17:29:41.530]   - Field: 'asynchronous'
[17:29:41.531]   - Field: 'calls'
[17:29:41.531]   - Field: 'globals'
[17:29:41.531]   - Field: 'stdout'
[17:29:41.531]   - Field: 'earlySignal'
[17:29:41.531]   - Field: 'lazy'
[17:29:41.532]   - Field: 'state'
[17:29:41.532] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.532] - Launch lazy future ...
[17:29:41.532] Packages needed by the future expression (n = 0): <none>
[17:29:41.532] Packages needed by future strategies (n = 0): <none>
[17:29:41.533] {
[17:29:41.533]     {
[17:29:41.533]         {
[17:29:41.533]             ...future.startTime <- base::Sys.time()
[17:29:41.533]             {
[17:29:41.533]                 {
[17:29:41.533]                   {
[17:29:41.533]                     base::local({
[17:29:41.533]                       has_future <- base::requireNamespace("future", 
[17:29:41.533]                         quietly = TRUE)
[17:29:41.533]                       if (has_future) {
[17:29:41.533]                         ns <- base::getNamespace("future")
[17:29:41.533]                         version <- ns[[".package"]][["version"]]
[17:29:41.533]                         if (is.null(version)) 
[17:29:41.533]                           version <- utils::packageVersion("future")
[17:29:41.533]                       }
[17:29:41.533]                       else {
[17:29:41.533]                         version <- NULL
[17:29:41.533]                       }
[17:29:41.533]                       if (!has_future || version < "1.8.0") {
[17:29:41.533]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.533]                           "", base::R.version$version.string), 
[17:29:41.533]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.533]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.533]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.533]                             "release", "version")], collapse = " "), 
[17:29:41.533]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.533]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.533]                           info)
[17:29:41.533]                         info <- base::paste(info, collapse = "; ")
[17:29:41.533]                         if (!has_future) {
[17:29:41.533]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.533]                             info)
[17:29:41.533]                         }
[17:29:41.533]                         else {
[17:29:41.533]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.533]                             info, version)
[17:29:41.533]                         }
[17:29:41.533]                         base::stop(msg)
[17:29:41.533]                       }
[17:29:41.533]                     })
[17:29:41.533]                   }
[17:29:41.533]                   ...future.strategy.old <- future::plan("list")
[17:29:41.533]                   options(future.plan = NULL)
[17:29:41.533]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.533]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.533]                 }
[17:29:41.533]                 ...future.workdir <- getwd()
[17:29:41.533]             }
[17:29:41.533]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.533]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.533]         }
[17:29:41.533]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.533]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.533]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.533]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.533]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.533]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.533]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.533]             base::names(...future.oldOptions))
[17:29:41.533]     }
[17:29:41.533]     if (FALSE) {
[17:29:41.533]     }
[17:29:41.533]     else {
[17:29:41.533]         if (TRUE) {
[17:29:41.533]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.533]                 open = "w")
[17:29:41.533]         }
[17:29:41.533]         else {
[17:29:41.533]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.533]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.533]         }
[17:29:41.533]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.533]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.533]             base::sink(type = "output", split = FALSE)
[17:29:41.533]             base::close(...future.stdout)
[17:29:41.533]         }, add = TRUE)
[17:29:41.533]     }
[17:29:41.533]     ...future.frame <- base::sys.nframe()
[17:29:41.533]     ...future.conditions <- base::list()
[17:29:41.533]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.533]     if (FALSE) {
[17:29:41.533]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.533]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.533]     }
[17:29:41.533]     ...future.result <- base::tryCatch({
[17:29:41.533]         base::withCallingHandlers({
[17:29:41.533]             ...future.value <- base::withVisible(base::local({
[17:29:41.533]                 sample(x, size = 1L)
[17:29:41.533]             }))
[17:29:41.533]             future::FutureResult(value = ...future.value$value, 
[17:29:41.533]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.533]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.533]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.533]                     ...future.globalenv.names))
[17:29:41.533]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.533]         }, condition = base::local({
[17:29:41.533]             c <- base::c
[17:29:41.533]             inherits <- base::inherits
[17:29:41.533]             invokeRestart <- base::invokeRestart
[17:29:41.533]             length <- base::length
[17:29:41.533]             list <- base::list
[17:29:41.533]             seq.int <- base::seq.int
[17:29:41.533]             signalCondition <- base::signalCondition
[17:29:41.533]             sys.calls <- base::sys.calls
[17:29:41.533]             `[[` <- base::`[[`
[17:29:41.533]             `+` <- base::`+`
[17:29:41.533]             `<<-` <- base::`<<-`
[17:29:41.533]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.533]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.533]                   3L)]
[17:29:41.533]             }
[17:29:41.533]             function(cond) {
[17:29:41.533]                 is_error <- inherits(cond, "error")
[17:29:41.533]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.533]                   NULL)
[17:29:41.533]                 if (is_error) {
[17:29:41.533]                   sessionInformation <- function() {
[17:29:41.533]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.533]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.533]                       search = base::search(), system = base::Sys.info())
[17:29:41.533]                   }
[17:29:41.533]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.533]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.533]                     cond$call), session = sessionInformation(), 
[17:29:41.533]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.533]                   signalCondition(cond)
[17:29:41.533]                 }
[17:29:41.533]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.533]                 "immediateCondition"))) {
[17:29:41.533]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.533]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.533]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.533]                   if (TRUE && !signal) {
[17:29:41.533]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.533]                     {
[17:29:41.533]                       inherits <- base::inherits
[17:29:41.533]                       invokeRestart <- base::invokeRestart
[17:29:41.533]                       is.null <- base::is.null
[17:29:41.533]                       muffled <- FALSE
[17:29:41.533]                       if (inherits(cond, "message")) {
[17:29:41.533]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.533]                         if (muffled) 
[17:29:41.533]                           invokeRestart("muffleMessage")
[17:29:41.533]                       }
[17:29:41.533]                       else if (inherits(cond, "warning")) {
[17:29:41.533]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.533]                         if (muffled) 
[17:29:41.533]                           invokeRestart("muffleWarning")
[17:29:41.533]                       }
[17:29:41.533]                       else if (inherits(cond, "condition")) {
[17:29:41.533]                         if (!is.null(pattern)) {
[17:29:41.533]                           computeRestarts <- base::computeRestarts
[17:29:41.533]                           grepl <- base::grepl
[17:29:41.533]                           restarts <- computeRestarts(cond)
[17:29:41.533]                           for (restart in restarts) {
[17:29:41.533]                             name <- restart$name
[17:29:41.533]                             if (is.null(name)) 
[17:29:41.533]                               next
[17:29:41.533]                             if (!grepl(pattern, name)) 
[17:29:41.533]                               next
[17:29:41.533]                             invokeRestart(restart)
[17:29:41.533]                             muffled <- TRUE
[17:29:41.533]                             break
[17:29:41.533]                           }
[17:29:41.533]                         }
[17:29:41.533]                       }
[17:29:41.533]                       invisible(muffled)
[17:29:41.533]                     }
[17:29:41.533]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.533]                   }
[17:29:41.533]                 }
[17:29:41.533]                 else {
[17:29:41.533]                   if (TRUE) {
[17:29:41.533]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.533]                     {
[17:29:41.533]                       inherits <- base::inherits
[17:29:41.533]                       invokeRestart <- base::invokeRestart
[17:29:41.533]                       is.null <- base::is.null
[17:29:41.533]                       muffled <- FALSE
[17:29:41.533]                       if (inherits(cond, "message")) {
[17:29:41.533]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.533]                         if (muffled) 
[17:29:41.533]                           invokeRestart("muffleMessage")
[17:29:41.533]                       }
[17:29:41.533]                       else if (inherits(cond, "warning")) {
[17:29:41.533]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.533]                         if (muffled) 
[17:29:41.533]                           invokeRestart("muffleWarning")
[17:29:41.533]                       }
[17:29:41.533]                       else if (inherits(cond, "condition")) {
[17:29:41.533]                         if (!is.null(pattern)) {
[17:29:41.533]                           computeRestarts <- base::computeRestarts
[17:29:41.533]                           grepl <- base::grepl
[17:29:41.533]                           restarts <- computeRestarts(cond)
[17:29:41.533]                           for (restart in restarts) {
[17:29:41.533]                             name <- restart$name
[17:29:41.533]                             if (is.null(name)) 
[17:29:41.533]                               next
[17:29:41.533]                             if (!grepl(pattern, name)) 
[17:29:41.533]                               next
[17:29:41.533]                             invokeRestart(restart)
[17:29:41.533]                             muffled <- TRUE
[17:29:41.533]                             break
[17:29:41.533]                           }
[17:29:41.533]                         }
[17:29:41.533]                       }
[17:29:41.533]                       invisible(muffled)
[17:29:41.533]                     }
[17:29:41.533]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.533]                   }
[17:29:41.533]                 }
[17:29:41.533]             }
[17:29:41.533]         }))
[17:29:41.533]     }, error = function(ex) {
[17:29:41.533]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.533]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.533]                 ...future.rng), started = ...future.startTime, 
[17:29:41.533]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.533]             version = "1.8"), class = "FutureResult")
[17:29:41.533]     }, finally = {
[17:29:41.533]         if (!identical(...future.workdir, getwd())) 
[17:29:41.533]             setwd(...future.workdir)
[17:29:41.533]         {
[17:29:41.533]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.533]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.533]             }
[17:29:41.533]             base::options(...future.oldOptions)
[17:29:41.533]             if (.Platform$OS.type == "windows") {
[17:29:41.533]                 old_names <- names(...future.oldEnvVars)
[17:29:41.533]                 envs <- base::Sys.getenv()
[17:29:41.533]                 names <- names(envs)
[17:29:41.533]                 common <- intersect(names, old_names)
[17:29:41.533]                 added <- setdiff(names, old_names)
[17:29:41.533]                 removed <- setdiff(old_names, names)
[17:29:41.533]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.533]                   envs[common]]
[17:29:41.533]                 NAMES <- toupper(changed)
[17:29:41.533]                 args <- list()
[17:29:41.533]                 for (kk in seq_along(NAMES)) {
[17:29:41.533]                   name <- changed[[kk]]
[17:29:41.533]                   NAME <- NAMES[[kk]]
[17:29:41.533]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.533]                     next
[17:29:41.533]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.533]                 }
[17:29:41.533]                 NAMES <- toupper(added)
[17:29:41.533]                 for (kk in seq_along(NAMES)) {
[17:29:41.533]                   name <- added[[kk]]
[17:29:41.533]                   NAME <- NAMES[[kk]]
[17:29:41.533]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.533]                     next
[17:29:41.533]                   args[[name]] <- ""
[17:29:41.533]                 }
[17:29:41.533]                 NAMES <- toupper(removed)
[17:29:41.533]                 for (kk in seq_along(NAMES)) {
[17:29:41.533]                   name <- removed[[kk]]
[17:29:41.533]                   NAME <- NAMES[[kk]]
[17:29:41.533]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.533]                     next
[17:29:41.533]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.533]                 }
[17:29:41.533]                 if (length(args) > 0) 
[17:29:41.533]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.533]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.533]             }
[17:29:41.533]             else {
[17:29:41.533]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.533]             }
[17:29:41.533]             {
[17:29:41.533]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.533]                   0L) {
[17:29:41.533]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.533]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.533]                   base::options(opts)
[17:29:41.533]                 }
[17:29:41.533]                 {
[17:29:41.533]                   {
[17:29:41.533]                     base::assign(".Random.seed", c(10407L, 856904683L, 
[17:29:41.533]                     -1350766746L, 671031386L, -594096583L, 1128026338L, 
[17:29:41.533]                     1353014223L), envir = base::globalenv(), 
[17:29:41.533]                       inherits = FALSE)
[17:29:41.533]                     NULL
[17:29:41.533]                   }
[17:29:41.533]                   options(future.plan = NULL)
[17:29:41.533]                   if (is.na(NA_character_)) 
[17:29:41.533]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.533]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.533]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.533]                     .init = FALSE)
[17:29:41.533]                 }
[17:29:41.533]             }
[17:29:41.533]         }
[17:29:41.533]     })
[17:29:41.533]     if (TRUE) {
[17:29:41.533]         base::sink(type = "output", split = FALSE)
[17:29:41.533]         if (TRUE) {
[17:29:41.533]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.533]         }
[17:29:41.533]         else {
[17:29:41.533]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.533]         }
[17:29:41.533]         base::close(...future.stdout)
[17:29:41.533]         ...future.stdout <- NULL
[17:29:41.533]     }
[17:29:41.533]     ...future.result$conditions <- ...future.conditions
[17:29:41.533]     ...future.result$finished <- base::Sys.time()
[17:29:41.533]     ...future.result
[17:29:41.533] }
[17:29:41.538] assign_globals() ...
[17:29:41.538] List of 1
[17:29:41.538]  $ x: int [1:4] 0 1 2 3
[17:29:41.538]  - attr(*, "where")=List of 1
[17:29:41.538]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.538]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.538]  - attr(*, "resolved")= logi FALSE
[17:29:41.538]  - attr(*, "total_size")= int 133
[17:29:41.538]  - attr(*, "already-done")= logi TRUE
[17:29:41.541] - copied 'x' to environment
[17:29:41.541] assign_globals() ... done
[17:29:41.542] plan(): Setting new future strategy stack:
[17:29:41.542] List of future strategies:
[17:29:41.542] 1. sequential:
[17:29:41.542]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.542]    - tweaked: FALSE
[17:29:41.542]    - call: NULL
[17:29:41.542] plan(): nbrOfWorkers() = 1
[17:29:41.544] plan(): Setting new future strategy stack:
[17:29:41.544] List of future strategies:
[17:29:41.544] 1. sequential:
[17:29:41.544]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.544]    - tweaked: FALSE
[17:29:41.544]    - call: plan(strategy)
[17:29:41.545] plan(): nbrOfWorkers() = 1
[17:29:41.545] SequentialFuture started (and completed)
[17:29:41.545] - Launch lazy future ... done
[17:29:41.545] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_2-55130'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add7216ae8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.546] getGlobalsAndPackages() ...
[17:29:41.547] Searching for globals...
[17:29:41.550] - globals found: [3] '{', 'sample', 'x'
[17:29:41.550] Searching for globals ... DONE
[17:29:41.550] Resolving globals: FALSE
[17:29:41.551] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.552] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.553] - globals: [1] 'x'
[17:29:41.553] 
[17:29:41.553] getGlobalsAndPackages() ... DONE
[17:29:41.554] run() for 'Future' ...
[17:29:41.555] - state: 'created'
[17:29:41.555] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.556] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.556] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.557]   - Field: 'label'
[17:29:41.557]   - Field: 'local'
[17:29:41.557]   - Field: 'owner'
[17:29:41.558]   - Field: 'envir'
[17:29:41.558]   - Field: 'packages'
[17:29:41.558]   - Field: 'gc'
[17:29:41.559]   - Field: 'conditions'
[17:29:41.559]   - Field: 'expr'
[17:29:41.559]   - Field: 'uuid'
[17:29:41.560]   - Field: 'seed'
[17:29:41.560]   - Field: 'version'
[17:29:41.560]   - Field: 'result'
[17:29:41.561]   - Field: 'asynchronous'
[17:29:41.561]   - Field: 'calls'
[17:29:41.561]   - Field: 'globals'
[17:29:41.561]   - Field: 'stdout'
[17:29:41.562]   - Field: 'earlySignal'
[17:29:41.562]   - Field: 'lazy'
[17:29:41.562]   - Field: 'state'
[17:29:41.562] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.562] - Launch lazy future ...
[17:29:41.563] Packages needed by the future expression (n = 0): <none>
[17:29:41.563] Packages needed by future strategies (n = 0): <none>
[17:29:41.564] {
[17:29:41.564]     {
[17:29:41.564]         {
[17:29:41.564]             ...future.startTime <- base::Sys.time()
[17:29:41.564]             {
[17:29:41.564]                 {
[17:29:41.564]                   {
[17:29:41.564]                     base::local({
[17:29:41.564]                       has_future <- base::requireNamespace("future", 
[17:29:41.564]                         quietly = TRUE)
[17:29:41.564]                       if (has_future) {
[17:29:41.564]                         ns <- base::getNamespace("future")
[17:29:41.564]                         version <- ns[[".package"]][["version"]]
[17:29:41.564]                         if (is.null(version)) 
[17:29:41.564]                           version <- utils::packageVersion("future")
[17:29:41.564]                       }
[17:29:41.564]                       else {
[17:29:41.564]                         version <- NULL
[17:29:41.564]                       }
[17:29:41.564]                       if (!has_future || version < "1.8.0") {
[17:29:41.564]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.564]                           "", base::R.version$version.string), 
[17:29:41.564]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.564]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.564]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.564]                             "release", "version")], collapse = " "), 
[17:29:41.564]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.564]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.564]                           info)
[17:29:41.564]                         info <- base::paste(info, collapse = "; ")
[17:29:41.564]                         if (!has_future) {
[17:29:41.564]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.564]                             info)
[17:29:41.564]                         }
[17:29:41.564]                         else {
[17:29:41.564]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.564]                             info, version)
[17:29:41.564]                         }
[17:29:41.564]                         base::stop(msg)
[17:29:41.564]                       }
[17:29:41.564]                     })
[17:29:41.564]                   }
[17:29:41.564]                   ...future.strategy.old <- future::plan("list")
[17:29:41.564]                   options(future.plan = NULL)
[17:29:41.564]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.564]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.564]                 }
[17:29:41.564]                 ...future.workdir <- getwd()
[17:29:41.564]             }
[17:29:41.564]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.564]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.564]         }
[17:29:41.564]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.564]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.564]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.564]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.564]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.564]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.564]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.564]             base::names(...future.oldOptions))
[17:29:41.564]     }
[17:29:41.564]     if (FALSE) {
[17:29:41.564]     }
[17:29:41.564]     else {
[17:29:41.564]         if (TRUE) {
[17:29:41.564]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.564]                 open = "w")
[17:29:41.564]         }
[17:29:41.564]         else {
[17:29:41.564]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.564]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.564]         }
[17:29:41.564]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.564]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.564]             base::sink(type = "output", split = FALSE)
[17:29:41.564]             base::close(...future.stdout)
[17:29:41.564]         }, add = TRUE)
[17:29:41.564]     }
[17:29:41.564]     ...future.frame <- base::sys.nframe()
[17:29:41.564]     ...future.conditions <- base::list()
[17:29:41.564]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.564]     if (FALSE) {
[17:29:41.564]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.564]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.564]     }
[17:29:41.564]     ...future.result <- base::tryCatch({
[17:29:41.564]         base::withCallingHandlers({
[17:29:41.564]             ...future.value <- base::withVisible(base::local({
[17:29:41.564]                 sample(x, size = 1L)
[17:29:41.564]             }))
[17:29:41.564]             future::FutureResult(value = ...future.value$value, 
[17:29:41.564]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.564]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.564]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.564]                     ...future.globalenv.names))
[17:29:41.564]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.564]         }, condition = base::local({
[17:29:41.564]             c <- base::c
[17:29:41.564]             inherits <- base::inherits
[17:29:41.564]             invokeRestart <- base::invokeRestart
[17:29:41.564]             length <- base::length
[17:29:41.564]             list <- base::list
[17:29:41.564]             seq.int <- base::seq.int
[17:29:41.564]             signalCondition <- base::signalCondition
[17:29:41.564]             sys.calls <- base::sys.calls
[17:29:41.564]             `[[` <- base::`[[`
[17:29:41.564]             `+` <- base::`+`
[17:29:41.564]             `<<-` <- base::`<<-`
[17:29:41.564]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.564]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.564]                   3L)]
[17:29:41.564]             }
[17:29:41.564]             function(cond) {
[17:29:41.564]                 is_error <- inherits(cond, "error")
[17:29:41.564]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.564]                   NULL)
[17:29:41.564]                 if (is_error) {
[17:29:41.564]                   sessionInformation <- function() {
[17:29:41.564]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.564]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.564]                       search = base::search(), system = base::Sys.info())
[17:29:41.564]                   }
[17:29:41.564]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.564]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.564]                     cond$call), session = sessionInformation(), 
[17:29:41.564]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.564]                   signalCondition(cond)
[17:29:41.564]                 }
[17:29:41.564]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.564]                 "immediateCondition"))) {
[17:29:41.564]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.564]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.564]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.564]                   if (TRUE && !signal) {
[17:29:41.564]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.564]                     {
[17:29:41.564]                       inherits <- base::inherits
[17:29:41.564]                       invokeRestart <- base::invokeRestart
[17:29:41.564]                       is.null <- base::is.null
[17:29:41.564]                       muffled <- FALSE
[17:29:41.564]                       if (inherits(cond, "message")) {
[17:29:41.564]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.564]                         if (muffled) 
[17:29:41.564]                           invokeRestart("muffleMessage")
[17:29:41.564]                       }
[17:29:41.564]                       else if (inherits(cond, "warning")) {
[17:29:41.564]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.564]                         if (muffled) 
[17:29:41.564]                           invokeRestart("muffleWarning")
[17:29:41.564]                       }
[17:29:41.564]                       else if (inherits(cond, "condition")) {
[17:29:41.564]                         if (!is.null(pattern)) {
[17:29:41.564]                           computeRestarts <- base::computeRestarts
[17:29:41.564]                           grepl <- base::grepl
[17:29:41.564]                           restarts <- computeRestarts(cond)
[17:29:41.564]                           for (restart in restarts) {
[17:29:41.564]                             name <- restart$name
[17:29:41.564]                             if (is.null(name)) 
[17:29:41.564]                               next
[17:29:41.564]                             if (!grepl(pattern, name)) 
[17:29:41.564]                               next
[17:29:41.564]                             invokeRestart(restart)
[17:29:41.564]                             muffled <- TRUE
[17:29:41.564]                             break
[17:29:41.564]                           }
[17:29:41.564]                         }
[17:29:41.564]                       }
[17:29:41.564]                       invisible(muffled)
[17:29:41.564]                     }
[17:29:41.564]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.564]                   }
[17:29:41.564]                 }
[17:29:41.564]                 else {
[17:29:41.564]                   if (TRUE) {
[17:29:41.564]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.564]                     {
[17:29:41.564]                       inherits <- base::inherits
[17:29:41.564]                       invokeRestart <- base::invokeRestart
[17:29:41.564]                       is.null <- base::is.null
[17:29:41.564]                       muffled <- FALSE
[17:29:41.564]                       if (inherits(cond, "message")) {
[17:29:41.564]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.564]                         if (muffled) 
[17:29:41.564]                           invokeRestart("muffleMessage")
[17:29:41.564]                       }
[17:29:41.564]                       else if (inherits(cond, "warning")) {
[17:29:41.564]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.564]                         if (muffled) 
[17:29:41.564]                           invokeRestart("muffleWarning")
[17:29:41.564]                       }
[17:29:41.564]                       else if (inherits(cond, "condition")) {
[17:29:41.564]                         if (!is.null(pattern)) {
[17:29:41.564]                           computeRestarts <- base::computeRestarts
[17:29:41.564]                           grepl <- base::grepl
[17:29:41.564]                           restarts <- computeRestarts(cond)
[17:29:41.564]                           for (restart in restarts) {
[17:29:41.564]                             name <- restart$name
[17:29:41.564]                             if (is.null(name)) 
[17:29:41.564]                               next
[17:29:41.564]                             if (!grepl(pattern, name)) 
[17:29:41.564]                               next
[17:29:41.564]                             invokeRestart(restart)
[17:29:41.564]                             muffled <- TRUE
[17:29:41.564]                             break
[17:29:41.564]                           }
[17:29:41.564]                         }
[17:29:41.564]                       }
[17:29:41.564]                       invisible(muffled)
[17:29:41.564]                     }
[17:29:41.564]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.564]                   }
[17:29:41.564]                 }
[17:29:41.564]             }
[17:29:41.564]         }))
[17:29:41.564]     }, error = function(ex) {
[17:29:41.564]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.564]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.564]                 ...future.rng), started = ...future.startTime, 
[17:29:41.564]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.564]             version = "1.8"), class = "FutureResult")
[17:29:41.564]     }, finally = {
[17:29:41.564]         if (!identical(...future.workdir, getwd())) 
[17:29:41.564]             setwd(...future.workdir)
[17:29:41.564]         {
[17:29:41.564]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.564]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.564]             }
[17:29:41.564]             base::options(...future.oldOptions)
[17:29:41.564]             if (.Platform$OS.type == "windows") {
[17:29:41.564]                 old_names <- names(...future.oldEnvVars)
[17:29:41.564]                 envs <- base::Sys.getenv()
[17:29:41.564]                 names <- names(envs)
[17:29:41.564]                 common <- intersect(names, old_names)
[17:29:41.564]                 added <- setdiff(names, old_names)
[17:29:41.564]                 removed <- setdiff(old_names, names)
[17:29:41.564]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.564]                   envs[common]]
[17:29:41.564]                 NAMES <- toupper(changed)
[17:29:41.564]                 args <- list()
[17:29:41.564]                 for (kk in seq_along(NAMES)) {
[17:29:41.564]                   name <- changed[[kk]]
[17:29:41.564]                   NAME <- NAMES[[kk]]
[17:29:41.564]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.564]                     next
[17:29:41.564]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.564]                 }
[17:29:41.564]                 NAMES <- toupper(added)
[17:29:41.564]                 for (kk in seq_along(NAMES)) {
[17:29:41.564]                   name <- added[[kk]]
[17:29:41.564]                   NAME <- NAMES[[kk]]
[17:29:41.564]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.564]                     next
[17:29:41.564]                   args[[name]] <- ""
[17:29:41.564]                 }
[17:29:41.564]                 NAMES <- toupper(removed)
[17:29:41.564]                 for (kk in seq_along(NAMES)) {
[17:29:41.564]                   name <- removed[[kk]]
[17:29:41.564]                   NAME <- NAMES[[kk]]
[17:29:41.564]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.564]                     next
[17:29:41.564]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.564]                 }
[17:29:41.564]                 if (length(args) > 0) 
[17:29:41.564]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.564]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.564]             }
[17:29:41.564]             else {
[17:29:41.564]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.564]             }
[17:29:41.564]             {
[17:29:41.564]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.564]                   0L) {
[17:29:41.564]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.564]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.564]                   base::options(opts)
[17:29:41.564]                 }
[17:29:41.564]                 {
[17:29:41.564]                   {
[17:29:41.564]                     base::assign(".Random.seed", c(10407L, 671031386L, 
[17:29:41.564]                     -153206494L, -2079745448L, 1353014223L, -823645377L, 
[17:29:41.564]                     12183680L), envir = base::globalenv(), inherits = FALSE)
[17:29:41.564]                     NULL
[17:29:41.564]                   }
[17:29:41.564]                   options(future.plan = NULL)
[17:29:41.564]                   if (is.na(NA_character_)) 
[17:29:41.564]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.564]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.564]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.564]                     .init = FALSE)
[17:29:41.564]                 }
[17:29:41.564]             }
[17:29:41.564]         }
[17:29:41.564]     })
[17:29:41.564]     if (TRUE) {
[17:29:41.564]         base::sink(type = "output", split = FALSE)
[17:29:41.564]         if (TRUE) {
[17:29:41.564]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.564]         }
[17:29:41.564]         else {
[17:29:41.564]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.564]         }
[17:29:41.564]         base::close(...future.stdout)
[17:29:41.564]         ...future.stdout <- NULL
[17:29:41.564]     }
[17:29:41.564]     ...future.result$conditions <- ...future.conditions
[17:29:41.564]     ...future.result$finished <- base::Sys.time()
[17:29:41.564]     ...future.result
[17:29:41.564] }
[17:29:41.569] assign_globals() ...
[17:29:41.569] List of 1
[17:29:41.569]  $ x: int [1:4] 0 1 2 3
[17:29:41.569]  - attr(*, "where")=List of 1
[17:29:41.569]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.569]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.569]  - attr(*, "resolved")= logi FALSE
[17:29:41.569]  - attr(*, "total_size")= int 133
[17:29:41.569]  - attr(*, "already-done")= logi TRUE
[17:29:41.573] - copied 'x' to environment
[17:29:41.573] assign_globals() ... done
[17:29:41.573] plan(): Setting new future strategy stack:
[17:29:41.573] List of future strategies:
[17:29:41.573] 1. sequential:
[17:29:41.573]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.573]    - tweaked: FALSE
[17:29:41.573]    - call: NULL
[17:29:41.574] plan(): nbrOfWorkers() = 1
[17:29:41.576] plan(): Setting new future strategy stack:
[17:29:41.577] List of future strategies:
[17:29:41.577] 1. sequential:
[17:29:41.577]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.577]    - tweaked: FALSE
[17:29:41.577]    - call: plan(strategy)
[17:29:41.577] plan(): nbrOfWorkers() = 1
[17:29:41.578] SequentialFuture started (and completed)
[17:29:41.578] - Launch lazy future ... done
[17:29:41.578] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_3-426832'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add7216ae8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.579] getGlobalsAndPackages() ...
[17:29:41.579] Searching for globals...
[17:29:41.581] - globals found: [3] '{', 'sample', 'x'
[17:29:41.581] Searching for globals ... DONE
[17:29:41.581] Resolving globals: FALSE
[17:29:41.582] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.582] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.583] - globals: [1] 'x'
[17:29:41.583] 
[17:29:41.583] getGlobalsAndPackages() ... DONE
[17:29:41.583] run() for 'Future' ...
[17:29:41.583] - state: 'created'
[17:29:41.584] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.584] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.584] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.585]   - Field: 'label'
[17:29:41.585]   - Field: 'local'
[17:29:41.585]   - Field: 'owner'
[17:29:41.585]   - Field: 'envir'
[17:29:41.585]   - Field: 'packages'
[17:29:41.585]   - Field: 'gc'
[17:29:41.586]   - Field: 'conditions'
[17:29:41.586]   - Field: 'expr'
[17:29:41.586]   - Field: 'uuid'
[17:29:41.586]   - Field: 'seed'
[17:29:41.586]   - Field: 'version'
[17:29:41.587]   - Field: 'result'
[17:29:41.587]   - Field: 'asynchronous'
[17:29:41.587]   - Field: 'calls'
[17:29:41.587]   - Field: 'globals'
[17:29:41.587]   - Field: 'stdout'
[17:29:41.587]   - Field: 'earlySignal'
[17:29:41.588]   - Field: 'lazy'
[17:29:41.588]   - Field: 'state'
[17:29:41.588] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.588] - Launch lazy future ...
[17:29:41.588] Packages needed by the future expression (n = 0): <none>
[17:29:41.589] Packages needed by future strategies (n = 0): <none>
[17:29:41.589] {
[17:29:41.589]     {
[17:29:41.589]         {
[17:29:41.589]             ...future.startTime <- base::Sys.time()
[17:29:41.589]             {
[17:29:41.589]                 {
[17:29:41.589]                   {
[17:29:41.589]                     base::local({
[17:29:41.589]                       has_future <- base::requireNamespace("future", 
[17:29:41.589]                         quietly = TRUE)
[17:29:41.589]                       if (has_future) {
[17:29:41.589]                         ns <- base::getNamespace("future")
[17:29:41.589]                         version <- ns[[".package"]][["version"]]
[17:29:41.589]                         if (is.null(version)) 
[17:29:41.589]                           version <- utils::packageVersion("future")
[17:29:41.589]                       }
[17:29:41.589]                       else {
[17:29:41.589]                         version <- NULL
[17:29:41.589]                       }
[17:29:41.589]                       if (!has_future || version < "1.8.0") {
[17:29:41.589]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.589]                           "", base::R.version$version.string), 
[17:29:41.589]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.589]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.589]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.589]                             "release", "version")], collapse = " "), 
[17:29:41.589]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.589]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.589]                           info)
[17:29:41.589]                         info <- base::paste(info, collapse = "; ")
[17:29:41.589]                         if (!has_future) {
[17:29:41.589]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.589]                             info)
[17:29:41.589]                         }
[17:29:41.589]                         else {
[17:29:41.589]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.589]                             info, version)
[17:29:41.589]                         }
[17:29:41.589]                         base::stop(msg)
[17:29:41.589]                       }
[17:29:41.589]                     })
[17:29:41.589]                   }
[17:29:41.589]                   ...future.strategy.old <- future::plan("list")
[17:29:41.589]                   options(future.plan = NULL)
[17:29:41.589]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.589]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.589]                 }
[17:29:41.589]                 ...future.workdir <- getwd()
[17:29:41.589]             }
[17:29:41.589]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.589]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.589]         }
[17:29:41.589]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.589]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.589]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.589]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.589]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.589]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.589]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.589]             base::names(...future.oldOptions))
[17:29:41.589]     }
[17:29:41.589]     if (FALSE) {
[17:29:41.589]     }
[17:29:41.589]     else {
[17:29:41.589]         if (TRUE) {
[17:29:41.589]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.589]                 open = "w")
[17:29:41.589]         }
[17:29:41.589]         else {
[17:29:41.589]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.589]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.589]         }
[17:29:41.589]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.589]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.589]             base::sink(type = "output", split = FALSE)
[17:29:41.589]             base::close(...future.stdout)
[17:29:41.589]         }, add = TRUE)
[17:29:41.589]     }
[17:29:41.589]     ...future.frame <- base::sys.nframe()
[17:29:41.589]     ...future.conditions <- base::list()
[17:29:41.589]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.589]     if (FALSE) {
[17:29:41.589]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.589]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.589]     }
[17:29:41.589]     ...future.result <- base::tryCatch({
[17:29:41.589]         base::withCallingHandlers({
[17:29:41.589]             ...future.value <- base::withVisible(base::local({
[17:29:41.589]                 sample(x, size = 1L)
[17:29:41.589]             }))
[17:29:41.589]             future::FutureResult(value = ...future.value$value, 
[17:29:41.589]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.589]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.589]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.589]                     ...future.globalenv.names))
[17:29:41.589]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.589]         }, condition = base::local({
[17:29:41.589]             c <- base::c
[17:29:41.589]             inherits <- base::inherits
[17:29:41.589]             invokeRestart <- base::invokeRestart
[17:29:41.589]             length <- base::length
[17:29:41.589]             list <- base::list
[17:29:41.589]             seq.int <- base::seq.int
[17:29:41.589]             signalCondition <- base::signalCondition
[17:29:41.589]             sys.calls <- base::sys.calls
[17:29:41.589]             `[[` <- base::`[[`
[17:29:41.589]             `+` <- base::`+`
[17:29:41.589]             `<<-` <- base::`<<-`
[17:29:41.589]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.589]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.589]                   3L)]
[17:29:41.589]             }
[17:29:41.589]             function(cond) {
[17:29:41.589]                 is_error <- inherits(cond, "error")
[17:29:41.589]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.589]                   NULL)
[17:29:41.589]                 if (is_error) {
[17:29:41.589]                   sessionInformation <- function() {
[17:29:41.589]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.589]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.589]                       search = base::search(), system = base::Sys.info())
[17:29:41.589]                   }
[17:29:41.589]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.589]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.589]                     cond$call), session = sessionInformation(), 
[17:29:41.589]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.589]                   signalCondition(cond)
[17:29:41.589]                 }
[17:29:41.589]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.589]                 "immediateCondition"))) {
[17:29:41.589]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.589]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.589]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.589]                   if (TRUE && !signal) {
[17:29:41.589]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.589]                     {
[17:29:41.589]                       inherits <- base::inherits
[17:29:41.589]                       invokeRestart <- base::invokeRestart
[17:29:41.589]                       is.null <- base::is.null
[17:29:41.589]                       muffled <- FALSE
[17:29:41.589]                       if (inherits(cond, "message")) {
[17:29:41.589]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.589]                         if (muffled) 
[17:29:41.589]                           invokeRestart("muffleMessage")
[17:29:41.589]                       }
[17:29:41.589]                       else if (inherits(cond, "warning")) {
[17:29:41.589]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.589]                         if (muffled) 
[17:29:41.589]                           invokeRestart("muffleWarning")
[17:29:41.589]                       }
[17:29:41.589]                       else if (inherits(cond, "condition")) {
[17:29:41.589]                         if (!is.null(pattern)) {
[17:29:41.589]                           computeRestarts <- base::computeRestarts
[17:29:41.589]                           grepl <- base::grepl
[17:29:41.589]                           restarts <- computeRestarts(cond)
[17:29:41.589]                           for (restart in restarts) {
[17:29:41.589]                             name <- restart$name
[17:29:41.589]                             if (is.null(name)) 
[17:29:41.589]                               next
[17:29:41.589]                             if (!grepl(pattern, name)) 
[17:29:41.589]                               next
[17:29:41.589]                             invokeRestart(restart)
[17:29:41.589]                             muffled <- TRUE
[17:29:41.589]                             break
[17:29:41.589]                           }
[17:29:41.589]                         }
[17:29:41.589]                       }
[17:29:41.589]                       invisible(muffled)
[17:29:41.589]                     }
[17:29:41.589]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.589]                   }
[17:29:41.589]                 }
[17:29:41.589]                 else {
[17:29:41.589]                   if (TRUE) {
[17:29:41.589]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.589]                     {
[17:29:41.589]                       inherits <- base::inherits
[17:29:41.589]                       invokeRestart <- base::invokeRestart
[17:29:41.589]                       is.null <- base::is.null
[17:29:41.589]                       muffled <- FALSE
[17:29:41.589]                       if (inherits(cond, "message")) {
[17:29:41.589]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.589]                         if (muffled) 
[17:29:41.589]                           invokeRestart("muffleMessage")
[17:29:41.589]                       }
[17:29:41.589]                       else if (inherits(cond, "warning")) {
[17:29:41.589]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.589]                         if (muffled) 
[17:29:41.589]                           invokeRestart("muffleWarning")
[17:29:41.589]                       }
[17:29:41.589]                       else if (inherits(cond, "condition")) {
[17:29:41.589]                         if (!is.null(pattern)) {
[17:29:41.589]                           computeRestarts <- base::computeRestarts
[17:29:41.589]                           grepl <- base::grepl
[17:29:41.589]                           restarts <- computeRestarts(cond)
[17:29:41.589]                           for (restart in restarts) {
[17:29:41.589]                             name <- restart$name
[17:29:41.589]                             if (is.null(name)) 
[17:29:41.589]                               next
[17:29:41.589]                             if (!grepl(pattern, name)) 
[17:29:41.589]                               next
[17:29:41.589]                             invokeRestart(restart)
[17:29:41.589]                             muffled <- TRUE
[17:29:41.589]                             break
[17:29:41.589]                           }
[17:29:41.589]                         }
[17:29:41.589]                       }
[17:29:41.589]                       invisible(muffled)
[17:29:41.589]                     }
[17:29:41.589]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.589]                   }
[17:29:41.589]                 }
[17:29:41.589]             }
[17:29:41.589]         }))
[17:29:41.589]     }, error = function(ex) {
[17:29:41.589]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.589]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.589]                 ...future.rng), started = ...future.startTime, 
[17:29:41.589]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.589]             version = "1.8"), class = "FutureResult")
[17:29:41.589]     }, finally = {
[17:29:41.589]         if (!identical(...future.workdir, getwd())) 
[17:29:41.589]             setwd(...future.workdir)
[17:29:41.589]         {
[17:29:41.589]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.589]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.589]             }
[17:29:41.589]             base::options(...future.oldOptions)
[17:29:41.589]             if (.Platform$OS.type == "windows") {
[17:29:41.589]                 old_names <- names(...future.oldEnvVars)
[17:29:41.589]                 envs <- base::Sys.getenv()
[17:29:41.589]                 names <- names(envs)
[17:29:41.589]                 common <- intersect(names, old_names)
[17:29:41.589]                 added <- setdiff(names, old_names)
[17:29:41.589]                 removed <- setdiff(old_names, names)
[17:29:41.589]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.589]                   envs[common]]
[17:29:41.589]                 NAMES <- toupper(changed)
[17:29:41.589]                 args <- list()
[17:29:41.589]                 for (kk in seq_along(NAMES)) {
[17:29:41.589]                   name <- changed[[kk]]
[17:29:41.589]                   NAME <- NAMES[[kk]]
[17:29:41.589]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.589]                     next
[17:29:41.589]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.589]                 }
[17:29:41.589]                 NAMES <- toupper(added)
[17:29:41.589]                 for (kk in seq_along(NAMES)) {
[17:29:41.589]                   name <- added[[kk]]
[17:29:41.589]                   NAME <- NAMES[[kk]]
[17:29:41.589]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.589]                     next
[17:29:41.589]                   args[[name]] <- ""
[17:29:41.589]                 }
[17:29:41.589]                 NAMES <- toupper(removed)
[17:29:41.589]                 for (kk in seq_along(NAMES)) {
[17:29:41.589]                   name <- removed[[kk]]
[17:29:41.589]                   NAME <- NAMES[[kk]]
[17:29:41.589]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.589]                     next
[17:29:41.589]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.589]                 }
[17:29:41.589]                 if (length(args) > 0) 
[17:29:41.589]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.589]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.589]             }
[17:29:41.589]             else {
[17:29:41.589]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.589]             }
[17:29:41.589]             {
[17:29:41.589]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.589]                   0L) {
[17:29:41.589]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.589]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.589]                   base::options(opts)
[17:29:41.589]                 }
[17:29:41.589]                 {
[17:29:41.589]                   {
[17:29:41.589]                     base::assign(".Random.seed", c(10407L, -2079745448L, 
[17:29:41.589]                     1207177463L, 914861718L, 12183680L, 475207752L, 
[17:29:41.589]                     -1525619580L), envir = base::globalenv(), 
[17:29:41.589]                       inherits = FALSE)
[17:29:41.589]                     NULL
[17:29:41.589]                   }
[17:29:41.589]                   options(future.plan = NULL)
[17:29:41.589]                   if (is.na(NA_character_)) 
[17:29:41.589]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.589]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.589]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.589]                     .init = FALSE)
[17:29:41.589]                 }
[17:29:41.589]             }
[17:29:41.589]         }
[17:29:41.589]     })
[17:29:41.589]     if (TRUE) {
[17:29:41.589]         base::sink(type = "output", split = FALSE)
[17:29:41.589]         if (TRUE) {
[17:29:41.589]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.589]         }
[17:29:41.589]         else {
[17:29:41.589]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.589]         }
[17:29:41.589]         base::close(...future.stdout)
[17:29:41.589]         ...future.stdout <- NULL
[17:29:41.589]     }
[17:29:41.589]     ...future.result$conditions <- ...future.conditions
[17:29:41.589]     ...future.result$finished <- base::Sys.time()
[17:29:41.589]     ...future.result
[17:29:41.589] }
[17:29:41.593] assign_globals() ...
[17:29:41.593] List of 1
[17:29:41.593]  $ x: int [1:4] 0 1 2 3
[17:29:41.593]  - attr(*, "where")=List of 1
[17:29:41.593]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.593]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.593]  - attr(*, "resolved")= logi FALSE
[17:29:41.593]  - attr(*, "total_size")= int 133
[17:29:41.593]  - attr(*, "already-done")= logi TRUE
[17:29:41.601] - copied 'x' to environment
[17:29:41.601] assign_globals() ... done
[17:29:41.602] plan(): Setting new future strategy stack:
[17:29:41.602] List of future strategies:
[17:29:41.602] 1. sequential:
[17:29:41.602]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.602]    - tweaked: FALSE
[17:29:41.602]    - call: NULL
[17:29:41.603] plan(): nbrOfWorkers() = 1
[17:29:41.605] plan(): Setting new future strategy stack:
[17:29:41.605] List of future strategies:
[17:29:41.605] 1. sequential:
[17:29:41.605]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.605]    - tweaked: FALSE
[17:29:41.605]    - call: plan(strategy)
[17:29:41.606] plan(): nbrOfWorkers() = 1
[17:29:41.607] SequentialFuture started (and completed)
[17:29:41.607] - Launch lazy future ... done
[17:29:41.607] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_4-37239'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add7216ae8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.609] resolve() on list ...
[17:29:41.609]  recursive: 0
[17:29:41.610]  length: 4
[17:29:41.610] 
[17:29:41.610] resolved() for 'SequentialFuture' ...
[17:29:41.611] - state: 'finished'
[17:29:41.611] - run: TRUE
[17:29:41.611] - result: 'FutureResult'
[17:29:41.612] resolved() for 'SequentialFuture' ... done
[17:29:41.612] Future #1
[17:29:41.613] signalConditionsASAP(SequentialFuture, pos=1) ...
[17:29:41.613] - nx: 4
[17:29:41.613] - relay: TRUE
[17:29:41.614] - stdout: TRUE
[17:29:41.614] - signal: TRUE
[17:29:41.614] - resignal: FALSE
[17:29:41.614] - force: TRUE
[17:29:41.615] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:41.615] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:41.615]  - until=1
[17:29:41.615]  - relaying element #1
[17:29:41.616] signalConditions() ...
[17:29:41.616]  - include = 'immediateCondition'
[17:29:41.616]  - exclude = 
[17:29:41.617]  - resignal = FALSE
[17:29:41.617]  - Number of conditions: 1
[17:29:41.617] signalConditions() ... done
[17:29:41.618] signalConditions() ...
[17:29:41.618]  - include = 'immediateCondition'
[17:29:41.618]  - exclude = 
[17:29:41.618]  - resignal = FALSE
[17:29:41.619]  - Number of conditions: 1
[17:29:41.619] signalConditions() ... done
[17:29:41.619] signalConditions() ...
[17:29:41.620]  - include = 'condition'
[17:29:41.620]  - exclude = 'immediateCondition'
[17:29:41.620]  - resignal = TRUE
[17:29:41.620]  - Number of conditions: 1
[17:29:41.621]  - Condition #1: 'RngFutureError', 'FutureError', 'error', 'RngFutureCondition', 'FutureCondition', 'condition'
[17:29:41.621] signalConditions() ... done
[17:29:41.621] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:41.622] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:41.622] signalConditionsASAP(SequentialFuture, pos=1) ... done
<RngFutureError: UNRELIABLE VALUE: Future ('fsample_1-218749') 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: c5b9dca4-cc62-2ee8-6e2c-38c95e03065c


DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
SequentialFuture:
Label: 'fsample_1-218749'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add7216ae8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Conditions captured: [n=1] 'RngFutureError'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'

DEBUG: END TROUBLESHOOTING HELP
[17:29:41.624] getGlobalsAndPackages() ...
[17:29:41.625] Searching for globals...
[17:29:41.627] - globals found: [3] '{', 'sample', 'x'
[17:29:41.627] Searching for globals ... DONE
[17:29:41.627] Resolving globals: FALSE
[17:29:41.628] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.629] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.629] - globals: [1] 'x'
[17:29:41.629] 
[17:29:41.630] getGlobalsAndPackages() ... DONE
[17:29:41.630] run() for 'Future' ...
[17:29:41.630] - state: 'created'
[17:29:41.631] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.631] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.632] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.632]   - Field: 'label'
[17:29:41.632]   - Field: 'local'
[17:29:41.633]   - Field: 'owner'
[17:29:41.633]   - Field: 'envir'
[17:29:41.633]   - Field: 'packages'
[17:29:41.634]   - Field: 'gc'
[17:29:41.634]   - Field: 'conditions'
[17:29:41.634]   - Field: 'expr'
[17:29:41.635]   - Field: 'uuid'
[17:29:41.635]   - Field: 'seed'
[17:29:41.635]   - Field: 'version'
[17:29:41.636]   - Field: 'result'
[17:29:41.636]   - Field: 'asynchronous'
[17:29:41.636]   - Field: 'calls'
[17:29:41.636]   - Field: 'globals'
[17:29:41.637]   - Field: 'stdout'
[17:29:41.637]   - Field: 'earlySignal'
[17:29:41.637]   - Field: 'lazy'
[17:29:41.638]   - Field: 'state'
[17:29:41.638] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.638] - Launch lazy future ...
[17:29:41.639] Packages needed by the future expression (n = 0): <none>
[17:29:41.639] Packages needed by future strategies (n = 0): <none>
[17:29:41.640] {
[17:29:41.640]     {
[17:29:41.640]         {
[17:29:41.640]             ...future.startTime <- base::Sys.time()
[17:29:41.640]             {
[17:29:41.640]                 {
[17:29:41.640]                   {
[17:29:41.640]                     base::local({
[17:29:41.640]                       has_future <- base::requireNamespace("future", 
[17:29:41.640]                         quietly = TRUE)
[17:29:41.640]                       if (has_future) {
[17:29:41.640]                         ns <- base::getNamespace("future")
[17:29:41.640]                         version <- ns[[".package"]][["version"]]
[17:29:41.640]                         if (is.null(version)) 
[17:29:41.640]                           version <- utils::packageVersion("future")
[17:29:41.640]                       }
[17:29:41.640]                       else {
[17:29:41.640]                         version <- NULL
[17:29:41.640]                       }
[17:29:41.640]                       if (!has_future || version < "1.8.0") {
[17:29:41.640]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.640]                           "", base::R.version$version.string), 
[17:29:41.640]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.640]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.640]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.640]                             "release", "version")], collapse = " "), 
[17:29:41.640]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.640]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.640]                           info)
[17:29:41.640]                         info <- base::paste(info, collapse = "; ")
[17:29:41.640]                         if (!has_future) {
[17:29:41.640]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.640]                             info)
[17:29:41.640]                         }
[17:29:41.640]                         else {
[17:29:41.640]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.640]                             info, version)
[17:29:41.640]                         }
[17:29:41.640]                         base::stop(msg)
[17:29:41.640]                       }
[17:29:41.640]                     })
[17:29:41.640]                   }
[17:29:41.640]                   ...future.strategy.old <- future::plan("list")
[17:29:41.640]                   options(future.plan = NULL)
[17:29:41.640]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.640]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.640]                 }
[17:29:41.640]                 ...future.workdir <- getwd()
[17:29:41.640]             }
[17:29:41.640]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.640]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.640]         }
[17:29:41.640]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.640]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.640]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.640]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.640]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.640]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.640]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.640]             base::names(...future.oldOptions))
[17:29:41.640]     }
[17:29:41.640]     if (FALSE) {
[17:29:41.640]     }
[17:29:41.640]     else {
[17:29:41.640]         if (TRUE) {
[17:29:41.640]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.640]                 open = "w")
[17:29:41.640]         }
[17:29:41.640]         else {
[17:29:41.640]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.640]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.640]         }
[17:29:41.640]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.640]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.640]             base::sink(type = "output", split = FALSE)
[17:29:41.640]             base::close(...future.stdout)
[17:29:41.640]         }, add = TRUE)
[17:29:41.640]     }
[17:29:41.640]     ...future.frame <- base::sys.nframe()
[17:29:41.640]     ...future.conditions <- base::list()
[17:29:41.640]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.640]     if (FALSE) {
[17:29:41.640]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.640]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.640]     }
[17:29:41.640]     ...future.result <- base::tryCatch({
[17:29:41.640]         base::withCallingHandlers({
[17:29:41.640]             ...future.value <- base::withVisible(base::local({
[17:29:41.640]                 sample(x, size = 1L)
[17:29:41.640]             }))
[17:29:41.640]             future::FutureResult(value = ...future.value$value, 
[17:29:41.640]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.640]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.640]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.640]                     ...future.globalenv.names))
[17:29:41.640]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.640]         }, condition = base::local({
[17:29:41.640]             c <- base::c
[17:29:41.640]             inherits <- base::inherits
[17:29:41.640]             invokeRestart <- base::invokeRestart
[17:29:41.640]             length <- base::length
[17:29:41.640]             list <- base::list
[17:29:41.640]             seq.int <- base::seq.int
[17:29:41.640]             signalCondition <- base::signalCondition
[17:29:41.640]             sys.calls <- base::sys.calls
[17:29:41.640]             `[[` <- base::`[[`
[17:29:41.640]             `+` <- base::`+`
[17:29:41.640]             `<<-` <- base::`<<-`
[17:29:41.640]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.640]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.640]                   3L)]
[17:29:41.640]             }
[17:29:41.640]             function(cond) {
[17:29:41.640]                 is_error <- inherits(cond, "error")
[17:29:41.640]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.640]                   NULL)
[17:29:41.640]                 if (is_error) {
[17:29:41.640]                   sessionInformation <- function() {
[17:29:41.640]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.640]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.640]                       search = base::search(), system = base::Sys.info())
[17:29:41.640]                   }
[17:29:41.640]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.640]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.640]                     cond$call), session = sessionInformation(), 
[17:29:41.640]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.640]                   signalCondition(cond)
[17:29:41.640]                 }
[17:29:41.640]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.640]                 "immediateCondition"))) {
[17:29:41.640]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.640]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.640]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.640]                   if (TRUE && !signal) {
[17:29:41.640]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.640]                     {
[17:29:41.640]                       inherits <- base::inherits
[17:29:41.640]                       invokeRestart <- base::invokeRestart
[17:29:41.640]                       is.null <- base::is.null
[17:29:41.640]                       muffled <- FALSE
[17:29:41.640]                       if (inherits(cond, "message")) {
[17:29:41.640]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.640]                         if (muffled) 
[17:29:41.640]                           invokeRestart("muffleMessage")
[17:29:41.640]                       }
[17:29:41.640]                       else if (inherits(cond, "warning")) {
[17:29:41.640]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.640]                         if (muffled) 
[17:29:41.640]                           invokeRestart("muffleWarning")
[17:29:41.640]                       }
[17:29:41.640]                       else if (inherits(cond, "condition")) {
[17:29:41.640]                         if (!is.null(pattern)) {
[17:29:41.640]                           computeRestarts <- base::computeRestarts
[17:29:41.640]                           grepl <- base::grepl
[17:29:41.640]                           restarts <- computeRestarts(cond)
[17:29:41.640]                           for (restart in restarts) {
[17:29:41.640]                             name <- restart$name
[17:29:41.640]                             if (is.null(name)) 
[17:29:41.640]                               next
[17:29:41.640]                             if (!grepl(pattern, name)) 
[17:29:41.640]                               next
[17:29:41.640]                             invokeRestart(restart)
[17:29:41.640]                             muffled <- TRUE
[17:29:41.640]                             break
[17:29:41.640]                           }
[17:29:41.640]                         }
[17:29:41.640]                       }
[17:29:41.640]                       invisible(muffled)
[17:29:41.640]                     }
[17:29:41.640]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.640]                   }
[17:29:41.640]                 }
[17:29:41.640]                 else {
[17:29:41.640]                   if (TRUE) {
[17:29:41.640]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.640]                     {
[17:29:41.640]                       inherits <- base::inherits
[17:29:41.640]                       invokeRestart <- base::invokeRestart
[17:29:41.640]                       is.null <- base::is.null
[17:29:41.640]                       muffled <- FALSE
[17:29:41.640]                       if (inherits(cond, "message")) {
[17:29:41.640]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.640]                         if (muffled) 
[17:29:41.640]                           invokeRestart("muffleMessage")
[17:29:41.640]                       }
[17:29:41.640]                       else if (inherits(cond, "warning")) {
[17:29:41.640]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.640]                         if (muffled) 
[17:29:41.640]                           invokeRestart("muffleWarning")
[17:29:41.640]                       }
[17:29:41.640]                       else if (inherits(cond, "condition")) {
[17:29:41.640]                         if (!is.null(pattern)) {
[17:29:41.640]                           computeRestarts <- base::computeRestarts
[17:29:41.640]                           grepl <- base::grepl
[17:29:41.640]                           restarts <- computeRestarts(cond)
[17:29:41.640]                           for (restart in restarts) {
[17:29:41.640]                             name <- restart$name
[17:29:41.640]                             if (is.null(name)) 
[17:29:41.640]                               next
[17:29:41.640]                             if (!grepl(pattern, name)) 
[17:29:41.640]                               next
[17:29:41.640]                             invokeRestart(restart)
[17:29:41.640]                             muffled <- TRUE
[17:29:41.640]                             break
[17:29:41.640]                           }
[17:29:41.640]                         }
[17:29:41.640]                       }
[17:29:41.640]                       invisible(muffled)
[17:29:41.640]                     }
[17:29:41.640]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.640]                   }
[17:29:41.640]                 }
[17:29:41.640]             }
[17:29:41.640]         }))
[17:29:41.640]     }, error = function(ex) {
[17:29:41.640]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.640]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.640]                 ...future.rng), started = ...future.startTime, 
[17:29:41.640]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.640]             version = "1.8"), class = "FutureResult")
[17:29:41.640]     }, finally = {
[17:29:41.640]         if (!identical(...future.workdir, getwd())) 
[17:29:41.640]             setwd(...future.workdir)
[17:29:41.640]         {
[17:29:41.640]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.640]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.640]             }
[17:29:41.640]             base::options(...future.oldOptions)
[17:29:41.640]             if (.Platform$OS.type == "windows") {
[17:29:41.640]                 old_names <- names(...future.oldEnvVars)
[17:29:41.640]                 envs <- base::Sys.getenv()
[17:29:41.640]                 names <- names(envs)
[17:29:41.640]                 common <- intersect(names, old_names)
[17:29:41.640]                 added <- setdiff(names, old_names)
[17:29:41.640]                 removed <- setdiff(old_names, names)
[17:29:41.640]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.640]                   envs[common]]
[17:29:41.640]                 NAMES <- toupper(changed)
[17:29:41.640]                 args <- list()
[17:29:41.640]                 for (kk in seq_along(NAMES)) {
[17:29:41.640]                   name <- changed[[kk]]
[17:29:41.640]                   NAME <- NAMES[[kk]]
[17:29:41.640]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.640]                     next
[17:29:41.640]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.640]                 }
[17:29:41.640]                 NAMES <- toupper(added)
[17:29:41.640]                 for (kk in seq_along(NAMES)) {
[17:29:41.640]                   name <- added[[kk]]
[17:29:41.640]                   NAME <- NAMES[[kk]]
[17:29:41.640]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.640]                     next
[17:29:41.640]                   args[[name]] <- ""
[17:29:41.640]                 }
[17:29:41.640]                 NAMES <- toupper(removed)
[17:29:41.640]                 for (kk in seq_along(NAMES)) {
[17:29:41.640]                   name <- removed[[kk]]
[17:29:41.640]                   NAME <- NAMES[[kk]]
[17:29:41.640]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.640]                     next
[17:29:41.640]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.640]                 }
[17:29:41.640]                 if (length(args) > 0) 
[17:29:41.640]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.640]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.640]             }
[17:29:41.640]             else {
[17:29:41.640]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.640]             }
[17:29:41.640]             {
[17:29:41.640]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.640]                   0L) {
[17:29:41.640]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.640]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.640]                   base::options(opts)
[17:29:41.640]                 }
[17:29:41.640]                 {
[17:29:41.640]                   {
[17:29:41.640]                     base::assign(".Random.seed", c(10407L, 494593694L, 
[17:29:41.640]                     -1181531031L, 730868446L, -1103241363L, -1143349626L, 
[17:29:41.640]                     1175253417L), envir = base::globalenv(), 
[17:29:41.640]                       inherits = FALSE)
[17:29:41.640]                     NULL
[17:29:41.640]                   }
[17:29:41.640]                   options(future.plan = NULL)
[17:29:41.640]                   if (is.na(NA_character_)) 
[17:29:41.640]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.640]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.640]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.640]                     .init = FALSE)
[17:29:41.640]                 }
[17:29:41.640]             }
[17:29:41.640]         }
[17:29:41.640]     })
[17:29:41.640]     if (TRUE) {
[17:29:41.640]         base::sink(type = "output", split = FALSE)
[17:29:41.640]         if (TRUE) {
[17:29:41.640]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.640]         }
[17:29:41.640]         else {
[17:29:41.640]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.640]         }
[17:29:41.640]         base::close(...future.stdout)
[17:29:41.640]         ...future.stdout <- NULL
[17:29:41.640]     }
[17:29:41.640]     ...future.result$conditions <- ...future.conditions
[17:29:41.640]     ...future.result$finished <- base::Sys.time()
[17:29:41.640]     ...future.result
[17:29:41.640] }
[17:29:41.647] assign_globals() ...
[17:29:41.647] List of 1
[17:29:41.647]  $ x: int [1:4] 0 1 2 3
[17:29:41.647]  - attr(*, "where")=List of 1
[17:29:41.647]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.647]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.647]  - attr(*, "resolved")= logi FALSE
[17:29:41.647]  - attr(*, "total_size")= int 133
[17:29:41.647]  - attr(*, "already-done")= logi TRUE
[17:29:41.656] - copied 'x' to environment
[17:29:41.656] assign_globals() ... done
[17:29:41.657] plan(): Setting new future strategy stack:
[17:29:41.657] List of future strategies:
[17:29:41.657] 1. sequential:
[17:29:41.657]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.657]    - tweaked: FALSE
[17:29:41.657]    - call: NULL
[17:29:41.658] plan(): nbrOfWorkers() = 1
[17:29:41.660] plan(): Setting new future strategy stack:
[17:29:41.660] List of future strategies:
[17:29:41.660] 1. sequential:
[17:29:41.660]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.660]    - tweaked: FALSE
[17:29:41.660]    - call: plan(strategy)
[17:29:41.661] plan(): nbrOfWorkers() = 1
[17:29:41.662] SequentialFuture started (and completed)
[17:29:41.662] - Launch lazy future ... done
[17:29:41.663] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_1-648580'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add712c8f0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.664] getGlobalsAndPackages() ...
[17:29:41.665] Searching for globals...
[17:29:41.667] - globals found: [3] '{', 'sample', 'x'
[17:29:41.667] Searching for globals ... DONE
[17:29:41.667] Resolving globals: FALSE
[17:29:41.668] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.669] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.669] - globals: [1] 'x'
[17:29:41.669] 
[17:29:41.670] getGlobalsAndPackages() ... DONE
[17:29:41.670] run() for 'Future' ...
[17:29:41.671] - state: 'created'
[17:29:41.671] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.672] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.672] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.672]   - Field: 'label'
[17:29:41.672]   - Field: 'local'
[17:29:41.673]   - Field: 'owner'
[17:29:41.673]   - Field: 'envir'
[17:29:41.673]   - Field: 'packages'
[17:29:41.674]   - Field: 'gc'
[17:29:41.674]   - Field: 'conditions'
[17:29:41.674]   - Field: 'expr'
[17:29:41.675]   - Field: 'uuid'
[17:29:41.675]   - Field: 'seed'
[17:29:41.675]   - Field: 'version'
[17:29:41.675]   - Field: 'result'
[17:29:41.676]   - Field: 'asynchronous'
[17:29:41.676]   - Field: 'calls'
[17:29:41.676]   - Field: 'globals'
[17:29:41.677]   - Field: 'stdout'
[17:29:41.677]   - Field: 'earlySignal'
[17:29:41.677]   - Field: 'lazy'
[17:29:41.677]   - Field: 'state'
[17:29:41.678] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.678] - Launch lazy future ...
[17:29:41.679] Packages needed by the future expression (n = 0): <none>
[17:29:41.679] Packages needed by future strategies (n = 0): <none>
[17:29:41.680] {
[17:29:41.680]     {
[17:29:41.680]         {
[17:29:41.680]             ...future.startTime <- base::Sys.time()
[17:29:41.680]             {
[17:29:41.680]                 {
[17:29:41.680]                   {
[17:29:41.680]                     base::local({
[17:29:41.680]                       has_future <- base::requireNamespace("future", 
[17:29:41.680]                         quietly = TRUE)
[17:29:41.680]                       if (has_future) {
[17:29:41.680]                         ns <- base::getNamespace("future")
[17:29:41.680]                         version <- ns[[".package"]][["version"]]
[17:29:41.680]                         if (is.null(version)) 
[17:29:41.680]                           version <- utils::packageVersion("future")
[17:29:41.680]                       }
[17:29:41.680]                       else {
[17:29:41.680]                         version <- NULL
[17:29:41.680]                       }
[17:29:41.680]                       if (!has_future || version < "1.8.0") {
[17:29:41.680]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.680]                           "", base::R.version$version.string), 
[17:29:41.680]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.680]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.680]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.680]                             "release", "version")], collapse = " "), 
[17:29:41.680]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.680]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.680]                           info)
[17:29:41.680]                         info <- base::paste(info, collapse = "; ")
[17:29:41.680]                         if (!has_future) {
[17:29:41.680]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.680]                             info)
[17:29:41.680]                         }
[17:29:41.680]                         else {
[17:29:41.680]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.680]                             info, version)
[17:29:41.680]                         }
[17:29:41.680]                         base::stop(msg)
[17:29:41.680]                       }
[17:29:41.680]                     })
[17:29:41.680]                   }
[17:29:41.680]                   ...future.strategy.old <- future::plan("list")
[17:29:41.680]                   options(future.plan = NULL)
[17:29:41.680]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.680]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.680]                 }
[17:29:41.680]                 ...future.workdir <- getwd()
[17:29:41.680]             }
[17:29:41.680]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.680]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.680]         }
[17:29:41.680]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.680]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.680]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.680]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.680]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.680]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.680]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.680]             base::names(...future.oldOptions))
[17:29:41.680]     }
[17:29:41.680]     if (FALSE) {
[17:29:41.680]     }
[17:29:41.680]     else {
[17:29:41.680]         if (TRUE) {
[17:29:41.680]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.680]                 open = "w")
[17:29:41.680]         }
[17:29:41.680]         else {
[17:29:41.680]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.680]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.680]         }
[17:29:41.680]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.680]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.680]             base::sink(type = "output", split = FALSE)
[17:29:41.680]             base::close(...future.stdout)
[17:29:41.680]         }, add = TRUE)
[17:29:41.680]     }
[17:29:41.680]     ...future.frame <- base::sys.nframe()
[17:29:41.680]     ...future.conditions <- base::list()
[17:29:41.680]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.680]     if (FALSE) {
[17:29:41.680]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.680]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.680]     }
[17:29:41.680]     ...future.result <- base::tryCatch({
[17:29:41.680]         base::withCallingHandlers({
[17:29:41.680]             ...future.value <- base::withVisible(base::local({
[17:29:41.680]                 sample(x, size = 1L)
[17:29:41.680]             }))
[17:29:41.680]             future::FutureResult(value = ...future.value$value, 
[17:29:41.680]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.680]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.680]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.680]                     ...future.globalenv.names))
[17:29:41.680]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.680]         }, condition = base::local({
[17:29:41.680]             c <- base::c
[17:29:41.680]             inherits <- base::inherits
[17:29:41.680]             invokeRestart <- base::invokeRestart
[17:29:41.680]             length <- base::length
[17:29:41.680]             list <- base::list
[17:29:41.680]             seq.int <- base::seq.int
[17:29:41.680]             signalCondition <- base::signalCondition
[17:29:41.680]             sys.calls <- base::sys.calls
[17:29:41.680]             `[[` <- base::`[[`
[17:29:41.680]             `+` <- base::`+`
[17:29:41.680]             `<<-` <- base::`<<-`
[17:29:41.680]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.680]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.680]                   3L)]
[17:29:41.680]             }
[17:29:41.680]             function(cond) {
[17:29:41.680]                 is_error <- inherits(cond, "error")
[17:29:41.680]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.680]                   NULL)
[17:29:41.680]                 if (is_error) {
[17:29:41.680]                   sessionInformation <- function() {
[17:29:41.680]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.680]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.680]                       search = base::search(), system = base::Sys.info())
[17:29:41.680]                   }
[17:29:41.680]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.680]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.680]                     cond$call), session = sessionInformation(), 
[17:29:41.680]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.680]                   signalCondition(cond)
[17:29:41.680]                 }
[17:29:41.680]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.680]                 "immediateCondition"))) {
[17:29:41.680]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.680]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.680]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.680]                   if (TRUE && !signal) {
[17:29:41.680]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.680]                     {
[17:29:41.680]                       inherits <- base::inherits
[17:29:41.680]                       invokeRestart <- base::invokeRestart
[17:29:41.680]                       is.null <- base::is.null
[17:29:41.680]                       muffled <- FALSE
[17:29:41.680]                       if (inherits(cond, "message")) {
[17:29:41.680]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.680]                         if (muffled) 
[17:29:41.680]                           invokeRestart("muffleMessage")
[17:29:41.680]                       }
[17:29:41.680]                       else if (inherits(cond, "warning")) {
[17:29:41.680]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.680]                         if (muffled) 
[17:29:41.680]                           invokeRestart("muffleWarning")
[17:29:41.680]                       }
[17:29:41.680]                       else if (inherits(cond, "condition")) {
[17:29:41.680]                         if (!is.null(pattern)) {
[17:29:41.680]                           computeRestarts <- base::computeRestarts
[17:29:41.680]                           grepl <- base::grepl
[17:29:41.680]                           restarts <- computeRestarts(cond)
[17:29:41.680]                           for (restart in restarts) {
[17:29:41.680]                             name <- restart$name
[17:29:41.680]                             if (is.null(name)) 
[17:29:41.680]                               next
[17:29:41.680]                             if (!grepl(pattern, name)) 
[17:29:41.680]                               next
[17:29:41.680]                             invokeRestart(restart)
[17:29:41.680]                             muffled <- TRUE
[17:29:41.680]                             break
[17:29:41.680]                           }
[17:29:41.680]                         }
[17:29:41.680]                       }
[17:29:41.680]                       invisible(muffled)
[17:29:41.680]                     }
[17:29:41.680]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.680]                   }
[17:29:41.680]                 }
[17:29:41.680]                 else {
[17:29:41.680]                   if (TRUE) {
[17:29:41.680]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.680]                     {
[17:29:41.680]                       inherits <- base::inherits
[17:29:41.680]                       invokeRestart <- base::invokeRestart
[17:29:41.680]                       is.null <- base::is.null
[17:29:41.680]                       muffled <- FALSE
[17:29:41.680]                       if (inherits(cond, "message")) {
[17:29:41.680]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.680]                         if (muffled) 
[17:29:41.680]                           invokeRestart("muffleMessage")
[17:29:41.680]                       }
[17:29:41.680]                       else if (inherits(cond, "warning")) {
[17:29:41.680]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.680]                         if (muffled) 
[17:29:41.680]                           invokeRestart("muffleWarning")
[17:29:41.680]                       }
[17:29:41.680]                       else if (inherits(cond, "condition")) {
[17:29:41.680]                         if (!is.null(pattern)) {
[17:29:41.680]                           computeRestarts <- base::computeRestarts
[17:29:41.680]                           grepl <- base::grepl
[17:29:41.680]                           restarts <- computeRestarts(cond)
[17:29:41.680]                           for (restart in restarts) {
[17:29:41.680]                             name <- restart$name
[17:29:41.680]                             if (is.null(name)) 
[17:29:41.680]                               next
[17:29:41.680]                             if (!grepl(pattern, name)) 
[17:29:41.680]                               next
[17:29:41.680]                             invokeRestart(restart)
[17:29:41.680]                             muffled <- TRUE
[17:29:41.680]                             break
[17:29:41.680]                           }
[17:29:41.680]                         }
[17:29:41.680]                       }
[17:29:41.680]                       invisible(muffled)
[17:29:41.680]                     }
[17:29:41.680]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.680]                   }
[17:29:41.680]                 }
[17:29:41.680]             }
[17:29:41.680]         }))
[17:29:41.680]     }, error = function(ex) {
[17:29:41.680]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.680]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.680]                 ...future.rng), started = ...future.startTime, 
[17:29:41.680]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.680]             version = "1.8"), class = "FutureResult")
[17:29:41.680]     }, finally = {
[17:29:41.680]         if (!identical(...future.workdir, getwd())) 
[17:29:41.680]             setwd(...future.workdir)
[17:29:41.680]         {
[17:29:41.680]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.680]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.680]             }
[17:29:41.680]             base::options(...future.oldOptions)
[17:29:41.680]             if (.Platform$OS.type == "windows") {
[17:29:41.680]                 old_names <- names(...future.oldEnvVars)
[17:29:41.680]                 envs <- base::Sys.getenv()
[17:29:41.680]                 names <- names(envs)
[17:29:41.680]                 common <- intersect(names, old_names)
[17:29:41.680]                 added <- setdiff(names, old_names)
[17:29:41.680]                 removed <- setdiff(old_names, names)
[17:29:41.680]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.680]                   envs[common]]
[17:29:41.680]                 NAMES <- toupper(changed)
[17:29:41.680]                 args <- list()
[17:29:41.680]                 for (kk in seq_along(NAMES)) {
[17:29:41.680]                   name <- changed[[kk]]
[17:29:41.680]                   NAME <- NAMES[[kk]]
[17:29:41.680]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.680]                     next
[17:29:41.680]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.680]                 }
[17:29:41.680]                 NAMES <- toupper(added)
[17:29:41.680]                 for (kk in seq_along(NAMES)) {
[17:29:41.680]                   name <- added[[kk]]
[17:29:41.680]                   NAME <- NAMES[[kk]]
[17:29:41.680]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.680]                     next
[17:29:41.680]                   args[[name]] <- ""
[17:29:41.680]                 }
[17:29:41.680]                 NAMES <- toupper(removed)
[17:29:41.680]                 for (kk in seq_along(NAMES)) {
[17:29:41.680]                   name <- removed[[kk]]
[17:29:41.680]                   NAME <- NAMES[[kk]]
[17:29:41.680]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.680]                     next
[17:29:41.680]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.680]                 }
[17:29:41.680]                 if (length(args) > 0) 
[17:29:41.680]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.680]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.680]             }
[17:29:41.680]             else {
[17:29:41.680]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.680]             }
[17:29:41.680]             {
[17:29:41.680]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.680]                   0L) {
[17:29:41.680]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.680]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.680]                   base::options(opts)
[17:29:41.680]                 }
[17:29:41.680]                 {
[17:29:41.680]                   {
[17:29:41.680]                     base::assign(".Random.seed", c(10407L, 730868446L, 
[17:29:41.680]                     1126349855L, -1174646151L, 1175253417L, 1985358547L, 
[17:29:41.680]                     -157742270L), envir = base::globalenv(), 
[17:29:41.680]                       inherits = FALSE)
[17:29:41.680]                     NULL
[17:29:41.680]                   }
[17:29:41.680]                   options(future.plan = NULL)
[17:29:41.680]                   if (is.na(NA_character_)) 
[17:29:41.680]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.680]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.680]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.680]                     .init = FALSE)
[17:29:41.680]                 }
[17:29:41.680]             }
[17:29:41.680]         }
[17:29:41.680]     })
[17:29:41.680]     if (TRUE) {
[17:29:41.680]         base::sink(type = "output", split = FALSE)
[17:29:41.680]         if (TRUE) {
[17:29:41.680]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.680]         }
[17:29:41.680]         else {
[17:29:41.680]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.680]         }
[17:29:41.680]         base::close(...future.stdout)
[17:29:41.680]         ...future.stdout <- NULL
[17:29:41.680]     }
[17:29:41.680]     ...future.result$conditions <- ...future.conditions
[17:29:41.680]     ...future.result$finished <- base::Sys.time()
[17:29:41.680]     ...future.result
[17:29:41.680] }
[17:29:41.684] assign_globals() ...
[17:29:41.684] List of 1
[17:29:41.684]  $ x: int [1:4] 0 1 2 3
[17:29:41.684]  - attr(*, "where")=List of 1
[17:29:41.684]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.684]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.684]  - attr(*, "resolved")= logi FALSE
[17:29:41.684]  - attr(*, "total_size")= int 133
[17:29:41.684]  - attr(*, "already-done")= logi TRUE
[17:29:41.688] - copied 'x' to environment
[17:29:41.688] assign_globals() ... done
[17:29:41.688] plan(): Setting new future strategy stack:
[17:29:41.689] List of future strategies:
[17:29:41.689] 1. sequential:
[17:29:41.689]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.689]    - tweaked: FALSE
[17:29:41.689]    - call: NULL
[17:29:41.690] plan(): nbrOfWorkers() = 1
[17:29:41.692] plan(): Setting new future strategy stack:
[17:29:41.692] List of future strategies:
[17:29:41.692] 1. sequential:
[17:29:41.692]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.692]    - tweaked: FALSE
[17:29:41.692]    - call: plan(strategy)
[17:29:41.693] plan(): nbrOfWorkers() = 1
[17:29:41.693] SequentialFuture started (and completed)
[17:29:41.693] - Launch lazy future ... done
[17:29:41.694] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_2-836452'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add712c8f0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.695] getGlobalsAndPackages() ...
[17:29:41.695] Searching for globals...
[17:29:41.700] - globals found: [3] '{', 'sample', 'x'
[17:29:41.700] Searching for globals ... DONE
[17:29:41.701] Resolving globals: FALSE
[17:29:41.701] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.702] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.702] - globals: [1] 'x'
[17:29:41.702] 
[17:29:41.703] getGlobalsAndPackages() ... DONE
[17:29:41.703] run() for 'Future' ...
[17:29:41.703] - state: 'created'
[17:29:41.704] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.704] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.704] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.705]   - Field: 'label'
[17:29:41.705]   - Field: 'local'
[17:29:41.705]   - Field: 'owner'
[17:29:41.705]   - Field: 'envir'
[17:29:41.706]   - Field: 'packages'
[17:29:41.706]   - Field: 'gc'
[17:29:41.706]   - Field: 'conditions'
[17:29:41.706]   - Field: 'expr'
[17:29:41.707]   - Field: 'uuid'
[17:29:41.707]   - Field: 'seed'
[17:29:41.707]   - Field: 'version'
[17:29:41.708]   - Field: 'result'
[17:29:41.708]   - Field: 'asynchronous'
[17:29:41.708]   - Field: 'calls'
[17:29:41.708]   - Field: 'globals'
[17:29:41.709]   - Field: 'stdout'
[17:29:41.709]   - Field: 'earlySignal'
[17:29:41.709]   - Field: 'lazy'
[17:29:41.710]   - Field: 'state'
[17:29:41.710] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.710] - Launch lazy future ...
[17:29:41.711] Packages needed by the future expression (n = 0): <none>
[17:29:41.711] Packages needed by future strategies (n = 0): <none>
[17:29:41.712] {
[17:29:41.712]     {
[17:29:41.712]         {
[17:29:41.712]             ...future.startTime <- base::Sys.time()
[17:29:41.712]             {
[17:29:41.712]                 {
[17:29:41.712]                   {
[17:29:41.712]                     base::local({
[17:29:41.712]                       has_future <- base::requireNamespace("future", 
[17:29:41.712]                         quietly = TRUE)
[17:29:41.712]                       if (has_future) {
[17:29:41.712]                         ns <- base::getNamespace("future")
[17:29:41.712]                         version <- ns[[".package"]][["version"]]
[17:29:41.712]                         if (is.null(version)) 
[17:29:41.712]                           version <- utils::packageVersion("future")
[17:29:41.712]                       }
[17:29:41.712]                       else {
[17:29:41.712]                         version <- NULL
[17:29:41.712]                       }
[17:29:41.712]                       if (!has_future || version < "1.8.0") {
[17:29:41.712]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.712]                           "", base::R.version$version.string), 
[17:29:41.712]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.712]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.712]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.712]                             "release", "version")], collapse = " "), 
[17:29:41.712]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.712]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.712]                           info)
[17:29:41.712]                         info <- base::paste(info, collapse = "; ")
[17:29:41.712]                         if (!has_future) {
[17:29:41.712]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.712]                             info)
[17:29:41.712]                         }
[17:29:41.712]                         else {
[17:29:41.712]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.712]                             info, version)
[17:29:41.712]                         }
[17:29:41.712]                         base::stop(msg)
[17:29:41.712]                       }
[17:29:41.712]                     })
[17:29:41.712]                   }
[17:29:41.712]                   ...future.strategy.old <- future::plan("list")
[17:29:41.712]                   options(future.plan = NULL)
[17:29:41.712]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.712]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.712]                 }
[17:29:41.712]                 ...future.workdir <- getwd()
[17:29:41.712]             }
[17:29:41.712]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.712]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.712]         }
[17:29:41.712]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.712]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.712]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.712]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.712]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.712]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.712]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.712]             base::names(...future.oldOptions))
[17:29:41.712]     }
[17:29:41.712]     if (FALSE) {
[17:29:41.712]     }
[17:29:41.712]     else {
[17:29:41.712]         if (TRUE) {
[17:29:41.712]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.712]                 open = "w")
[17:29:41.712]         }
[17:29:41.712]         else {
[17:29:41.712]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.712]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.712]         }
[17:29:41.712]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.712]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.712]             base::sink(type = "output", split = FALSE)
[17:29:41.712]             base::close(...future.stdout)
[17:29:41.712]         }, add = TRUE)
[17:29:41.712]     }
[17:29:41.712]     ...future.frame <- base::sys.nframe()
[17:29:41.712]     ...future.conditions <- base::list()
[17:29:41.712]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.712]     if (FALSE) {
[17:29:41.712]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.712]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.712]     }
[17:29:41.712]     ...future.result <- base::tryCatch({
[17:29:41.712]         base::withCallingHandlers({
[17:29:41.712]             ...future.value <- base::withVisible(base::local({
[17:29:41.712]                 sample(x, size = 1L)
[17:29:41.712]             }))
[17:29:41.712]             future::FutureResult(value = ...future.value$value, 
[17:29:41.712]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.712]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.712]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.712]                     ...future.globalenv.names))
[17:29:41.712]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.712]         }, condition = base::local({
[17:29:41.712]             c <- base::c
[17:29:41.712]             inherits <- base::inherits
[17:29:41.712]             invokeRestart <- base::invokeRestart
[17:29:41.712]             length <- base::length
[17:29:41.712]             list <- base::list
[17:29:41.712]             seq.int <- base::seq.int
[17:29:41.712]             signalCondition <- base::signalCondition
[17:29:41.712]             sys.calls <- base::sys.calls
[17:29:41.712]             `[[` <- base::`[[`
[17:29:41.712]             `+` <- base::`+`
[17:29:41.712]             `<<-` <- base::`<<-`
[17:29:41.712]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.712]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.712]                   3L)]
[17:29:41.712]             }
[17:29:41.712]             function(cond) {
[17:29:41.712]                 is_error <- inherits(cond, "error")
[17:29:41.712]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.712]                   NULL)
[17:29:41.712]                 if (is_error) {
[17:29:41.712]                   sessionInformation <- function() {
[17:29:41.712]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.712]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.712]                       search = base::search(), system = base::Sys.info())
[17:29:41.712]                   }
[17:29:41.712]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.712]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.712]                     cond$call), session = sessionInformation(), 
[17:29:41.712]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.712]                   signalCondition(cond)
[17:29:41.712]                 }
[17:29:41.712]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.712]                 "immediateCondition"))) {
[17:29:41.712]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.712]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.712]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.712]                   if (TRUE && !signal) {
[17:29:41.712]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.712]                     {
[17:29:41.712]                       inherits <- base::inherits
[17:29:41.712]                       invokeRestart <- base::invokeRestart
[17:29:41.712]                       is.null <- base::is.null
[17:29:41.712]                       muffled <- FALSE
[17:29:41.712]                       if (inherits(cond, "message")) {
[17:29:41.712]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.712]                         if (muffled) 
[17:29:41.712]                           invokeRestart("muffleMessage")
[17:29:41.712]                       }
[17:29:41.712]                       else if (inherits(cond, "warning")) {
[17:29:41.712]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.712]                         if (muffled) 
[17:29:41.712]                           invokeRestart("muffleWarning")
[17:29:41.712]                       }
[17:29:41.712]                       else if (inherits(cond, "condition")) {
[17:29:41.712]                         if (!is.null(pattern)) {
[17:29:41.712]                           computeRestarts <- base::computeRestarts
[17:29:41.712]                           grepl <- base::grepl
[17:29:41.712]                           restarts <- computeRestarts(cond)
[17:29:41.712]                           for (restart in restarts) {
[17:29:41.712]                             name <- restart$name
[17:29:41.712]                             if (is.null(name)) 
[17:29:41.712]                               next
[17:29:41.712]                             if (!grepl(pattern, name)) 
[17:29:41.712]                               next
[17:29:41.712]                             invokeRestart(restart)
[17:29:41.712]                             muffled <- TRUE
[17:29:41.712]                             break
[17:29:41.712]                           }
[17:29:41.712]                         }
[17:29:41.712]                       }
[17:29:41.712]                       invisible(muffled)
[17:29:41.712]                     }
[17:29:41.712]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.712]                   }
[17:29:41.712]                 }
[17:29:41.712]                 else {
[17:29:41.712]                   if (TRUE) {
[17:29:41.712]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.712]                     {
[17:29:41.712]                       inherits <- base::inherits
[17:29:41.712]                       invokeRestart <- base::invokeRestart
[17:29:41.712]                       is.null <- base::is.null
[17:29:41.712]                       muffled <- FALSE
[17:29:41.712]                       if (inherits(cond, "message")) {
[17:29:41.712]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.712]                         if (muffled) 
[17:29:41.712]                           invokeRestart("muffleMessage")
[17:29:41.712]                       }
[17:29:41.712]                       else if (inherits(cond, "warning")) {
[17:29:41.712]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.712]                         if (muffled) 
[17:29:41.712]                           invokeRestart("muffleWarning")
[17:29:41.712]                       }
[17:29:41.712]                       else if (inherits(cond, "condition")) {
[17:29:41.712]                         if (!is.null(pattern)) {
[17:29:41.712]                           computeRestarts <- base::computeRestarts
[17:29:41.712]                           grepl <- base::grepl
[17:29:41.712]                           restarts <- computeRestarts(cond)
[17:29:41.712]                           for (restart in restarts) {
[17:29:41.712]                             name <- restart$name
[17:29:41.712]                             if (is.null(name)) 
[17:29:41.712]                               next
[17:29:41.712]                             if (!grepl(pattern, name)) 
[17:29:41.712]                               next
[17:29:41.712]                             invokeRestart(restart)
[17:29:41.712]                             muffled <- TRUE
[17:29:41.712]                             break
[17:29:41.712]                           }
[17:29:41.712]                         }
[17:29:41.712]                       }
[17:29:41.712]                       invisible(muffled)
[17:29:41.712]                     }
[17:29:41.712]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.712]                   }
[17:29:41.712]                 }
[17:29:41.712]             }
[17:29:41.712]         }))
[17:29:41.712]     }, error = function(ex) {
[17:29:41.712]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.712]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.712]                 ...future.rng), started = ...future.startTime, 
[17:29:41.712]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.712]             version = "1.8"), class = "FutureResult")
[17:29:41.712]     }, finally = {
[17:29:41.712]         if (!identical(...future.workdir, getwd())) 
[17:29:41.712]             setwd(...future.workdir)
[17:29:41.712]         {
[17:29:41.712]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.712]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.712]             }
[17:29:41.712]             base::options(...future.oldOptions)
[17:29:41.712]             if (.Platform$OS.type == "windows") {
[17:29:41.712]                 old_names <- names(...future.oldEnvVars)
[17:29:41.712]                 envs <- base::Sys.getenv()
[17:29:41.712]                 names <- names(envs)
[17:29:41.712]                 common <- intersect(names, old_names)
[17:29:41.712]                 added <- setdiff(names, old_names)
[17:29:41.712]                 removed <- setdiff(old_names, names)
[17:29:41.712]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.712]                   envs[common]]
[17:29:41.712]                 NAMES <- toupper(changed)
[17:29:41.712]                 args <- list()
[17:29:41.712]                 for (kk in seq_along(NAMES)) {
[17:29:41.712]                   name <- changed[[kk]]
[17:29:41.712]                   NAME <- NAMES[[kk]]
[17:29:41.712]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.712]                     next
[17:29:41.712]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.712]                 }
[17:29:41.712]                 NAMES <- toupper(added)
[17:29:41.712]                 for (kk in seq_along(NAMES)) {
[17:29:41.712]                   name <- added[[kk]]
[17:29:41.712]                   NAME <- NAMES[[kk]]
[17:29:41.712]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.712]                     next
[17:29:41.712]                   args[[name]] <- ""
[17:29:41.712]                 }
[17:29:41.712]                 NAMES <- toupper(removed)
[17:29:41.712]                 for (kk in seq_along(NAMES)) {
[17:29:41.712]                   name <- removed[[kk]]
[17:29:41.712]                   NAME <- NAMES[[kk]]
[17:29:41.712]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.712]                     next
[17:29:41.712]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.712]                 }
[17:29:41.712]                 if (length(args) > 0) 
[17:29:41.712]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.712]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.712]             }
[17:29:41.712]             else {
[17:29:41.712]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.712]             }
[17:29:41.712]             {
[17:29:41.712]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.712]                   0L) {
[17:29:41.712]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.712]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.712]                   base::options(opts)
[17:29:41.712]                 }
[17:29:41.712]                 {
[17:29:41.712]                   {
[17:29:41.712]                     base::assign(".Random.seed", c(10407L, -1174646151L, 
[17:29:41.712]                     -1274838046L, 1936438221L, -157742270L, -665298496L, 
[17:29:41.712]                     -72351411L), envir = base::globalenv(), inherits = FALSE)
[17:29:41.712]                     NULL
[17:29:41.712]                   }
[17:29:41.712]                   options(future.plan = NULL)
[17:29:41.712]                   if (is.na(NA_character_)) 
[17:29:41.712]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.712]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.712]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.712]                     .init = FALSE)
[17:29:41.712]                 }
[17:29:41.712]             }
[17:29:41.712]         }
[17:29:41.712]     })
[17:29:41.712]     if (TRUE) {
[17:29:41.712]         base::sink(type = "output", split = FALSE)
[17:29:41.712]         if (TRUE) {
[17:29:41.712]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.712]         }
[17:29:41.712]         else {
[17:29:41.712]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.712]         }
[17:29:41.712]         base::close(...future.stdout)
[17:29:41.712]         ...future.stdout <- NULL
[17:29:41.712]     }
[17:29:41.712]     ...future.result$conditions <- ...future.conditions
[17:29:41.712]     ...future.result$finished <- base::Sys.time()
[17:29:41.712]     ...future.result
[17:29:41.712] }
[17:29:41.717] assign_globals() ...
[17:29:41.717] List of 1
[17:29:41.717]  $ x: int [1:4] 0 1 2 3
[17:29:41.717]  - attr(*, "where")=List of 1
[17:29:41.717]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.717]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.717]  - attr(*, "resolved")= logi FALSE
[17:29:41.717]  - attr(*, "total_size")= int 133
[17:29:41.717]  - attr(*, "already-done")= logi TRUE
[17:29:41.722] - copied 'x' to environment
[17:29:41.722] assign_globals() ... done
[17:29:41.723] plan(): Setting new future strategy stack:
[17:29:41.723] List of future strategies:
[17:29:41.723] 1. sequential:
[17:29:41.723]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.723]    - tweaked: FALSE
[17:29:41.723]    - call: NULL
[17:29:41.724] plan(): nbrOfWorkers() = 1
[17:29:41.726] plan(): Setting new future strategy stack:
[17:29:41.726] List of future strategies:
[17:29:41.726] 1. sequential:
[17:29:41.726]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.726]    - tweaked: FALSE
[17:29:41.726]    - call: plan(strategy)
[17:29:41.727] plan(): nbrOfWorkers() = 1
[17:29:41.727] SequentialFuture started (and completed)
[17:29:41.728] - Launch lazy future ... done
[17:29:41.728] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_3-751548'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add712c8f0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.730] getGlobalsAndPackages() ...
[17:29:41.730] Searching for globals...
[17:29:41.732] - globals found: [3] '{', 'sample', 'x'
[17:29:41.732] Searching for globals ... DONE
[17:29:41.733] Resolving globals: FALSE
[17:29:41.733] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.734] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.734] - globals: [1] 'x'
[17:29:41.734] 
[17:29:41.734] getGlobalsAndPackages() ... DONE
[17:29:41.735] run() for 'Future' ...
[17:29:41.735] - state: 'created'
[17:29:41.735] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.736] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.736] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.736]   - Field: 'label'
[17:29:41.736]   - Field: 'local'
[17:29:41.737]   - Field: 'owner'
[17:29:41.737]   - Field: 'envir'
[17:29:41.737]   - Field: 'packages'
[17:29:41.737]   - Field: 'gc'
[17:29:41.737]   - Field: 'conditions'
[17:29:41.738]   - Field: 'expr'
[17:29:41.738]   - Field: 'uuid'
[17:29:41.738]   - Field: 'seed'
[17:29:41.738]   - Field: 'version'
[17:29:41.738]   - Field: 'result'
[17:29:41.739]   - Field: 'asynchronous'
[17:29:41.739]   - Field: 'calls'
[17:29:41.739]   - Field: 'globals'
[17:29:41.739]   - Field: 'stdout'
[17:29:41.739]   - Field: 'earlySignal'
[17:29:41.739]   - Field: 'lazy'
[17:29:41.740]   - Field: 'state'
[17:29:41.740] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.740] - Launch lazy future ...
[17:29:41.740] Packages needed by the future expression (n = 0): <none>
[17:29:41.741] Packages needed by future strategies (n = 0): <none>
[17:29:41.741] {
[17:29:41.741]     {
[17:29:41.741]         {
[17:29:41.741]             ...future.startTime <- base::Sys.time()
[17:29:41.741]             {
[17:29:41.741]                 {
[17:29:41.741]                   {
[17:29:41.741]                     base::local({
[17:29:41.741]                       has_future <- base::requireNamespace("future", 
[17:29:41.741]                         quietly = TRUE)
[17:29:41.741]                       if (has_future) {
[17:29:41.741]                         ns <- base::getNamespace("future")
[17:29:41.741]                         version <- ns[[".package"]][["version"]]
[17:29:41.741]                         if (is.null(version)) 
[17:29:41.741]                           version <- utils::packageVersion("future")
[17:29:41.741]                       }
[17:29:41.741]                       else {
[17:29:41.741]                         version <- NULL
[17:29:41.741]                       }
[17:29:41.741]                       if (!has_future || version < "1.8.0") {
[17:29:41.741]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.741]                           "", base::R.version$version.string), 
[17:29:41.741]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:41.741]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.741]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.741]                             "release", "version")], collapse = " "), 
[17:29:41.741]                           hostname = base::Sys.info()[["nodename"]])
[17:29:41.741]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.741]                           info)
[17:29:41.741]                         info <- base::paste(info, collapse = "; ")
[17:29:41.741]                         if (!has_future) {
[17:29:41.741]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.741]                             info)
[17:29:41.741]                         }
[17:29:41.741]                         else {
[17:29:41.741]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.741]                             info, version)
[17:29:41.741]                         }
[17:29:41.741]                         base::stop(msg)
[17:29:41.741]                       }
[17:29:41.741]                     })
[17:29:41.741]                   }
[17:29:41.741]                   ...future.strategy.old <- future::plan("list")
[17:29:41.741]                   options(future.plan = NULL)
[17:29:41.741]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.741]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:41.741]                 }
[17:29:41.741]                 ...future.workdir <- getwd()
[17:29:41.741]             }
[17:29:41.741]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.741]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.741]         }
[17:29:41.741]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.741]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.741]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.741]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.741]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.741]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.741]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.741]             base::names(...future.oldOptions))
[17:29:41.741]     }
[17:29:41.741]     if (FALSE) {
[17:29:41.741]     }
[17:29:41.741]     else {
[17:29:41.741]         if (TRUE) {
[17:29:41.741]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.741]                 open = "w")
[17:29:41.741]         }
[17:29:41.741]         else {
[17:29:41.741]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.741]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.741]         }
[17:29:41.741]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.741]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.741]             base::sink(type = "output", split = FALSE)
[17:29:41.741]             base::close(...future.stdout)
[17:29:41.741]         }, add = TRUE)
[17:29:41.741]     }
[17:29:41.741]     ...future.frame <- base::sys.nframe()
[17:29:41.741]     ...future.conditions <- base::list()
[17:29:41.741]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.741]     if (FALSE) {
[17:29:41.741]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.741]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.741]     }
[17:29:41.741]     ...future.result <- base::tryCatch({
[17:29:41.741]         base::withCallingHandlers({
[17:29:41.741]             ...future.value <- base::withVisible(base::local({
[17:29:41.741]                 sample(x, size = 1L)
[17:29:41.741]             }))
[17:29:41.741]             future::FutureResult(value = ...future.value$value, 
[17:29:41.741]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.741]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.741]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.741]                     ...future.globalenv.names))
[17:29:41.741]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.741]         }, condition = base::local({
[17:29:41.741]             c <- base::c
[17:29:41.741]             inherits <- base::inherits
[17:29:41.741]             invokeRestart <- base::invokeRestart
[17:29:41.741]             length <- base::length
[17:29:41.741]             list <- base::list
[17:29:41.741]             seq.int <- base::seq.int
[17:29:41.741]             signalCondition <- base::signalCondition
[17:29:41.741]             sys.calls <- base::sys.calls
[17:29:41.741]             `[[` <- base::`[[`
[17:29:41.741]             `+` <- base::`+`
[17:29:41.741]             `<<-` <- base::`<<-`
[17:29:41.741]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.741]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.741]                   3L)]
[17:29:41.741]             }
[17:29:41.741]             function(cond) {
[17:29:41.741]                 is_error <- inherits(cond, "error")
[17:29:41.741]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.741]                   NULL)
[17:29:41.741]                 if (is_error) {
[17:29:41.741]                   sessionInformation <- function() {
[17:29:41.741]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.741]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.741]                       search = base::search(), system = base::Sys.info())
[17:29:41.741]                   }
[17:29:41.741]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.741]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.741]                     cond$call), session = sessionInformation(), 
[17:29:41.741]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.741]                   signalCondition(cond)
[17:29:41.741]                 }
[17:29:41.741]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.741]                 "immediateCondition"))) {
[17:29:41.741]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.741]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.741]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.741]                   if (TRUE && !signal) {
[17:29:41.741]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.741]                     {
[17:29:41.741]                       inherits <- base::inherits
[17:29:41.741]                       invokeRestart <- base::invokeRestart
[17:29:41.741]                       is.null <- base::is.null
[17:29:41.741]                       muffled <- FALSE
[17:29:41.741]                       if (inherits(cond, "message")) {
[17:29:41.741]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.741]                         if (muffled) 
[17:29:41.741]                           invokeRestart("muffleMessage")
[17:29:41.741]                       }
[17:29:41.741]                       else if (inherits(cond, "warning")) {
[17:29:41.741]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.741]                         if (muffled) 
[17:29:41.741]                           invokeRestart("muffleWarning")
[17:29:41.741]                       }
[17:29:41.741]                       else if (inherits(cond, "condition")) {
[17:29:41.741]                         if (!is.null(pattern)) {
[17:29:41.741]                           computeRestarts <- base::computeRestarts
[17:29:41.741]                           grepl <- base::grepl
[17:29:41.741]                           restarts <- computeRestarts(cond)
[17:29:41.741]                           for (restart in restarts) {
[17:29:41.741]                             name <- restart$name
[17:29:41.741]                             if (is.null(name)) 
[17:29:41.741]                               next
[17:29:41.741]                             if (!grepl(pattern, name)) 
[17:29:41.741]                               next
[17:29:41.741]                             invokeRestart(restart)
[17:29:41.741]                             muffled <- TRUE
[17:29:41.741]                             break
[17:29:41.741]                           }
[17:29:41.741]                         }
[17:29:41.741]                       }
[17:29:41.741]                       invisible(muffled)
[17:29:41.741]                     }
[17:29:41.741]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.741]                   }
[17:29:41.741]                 }
[17:29:41.741]                 else {
[17:29:41.741]                   if (TRUE) {
[17:29:41.741]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.741]                     {
[17:29:41.741]                       inherits <- base::inherits
[17:29:41.741]                       invokeRestart <- base::invokeRestart
[17:29:41.741]                       is.null <- base::is.null
[17:29:41.741]                       muffled <- FALSE
[17:29:41.741]                       if (inherits(cond, "message")) {
[17:29:41.741]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.741]                         if (muffled) 
[17:29:41.741]                           invokeRestart("muffleMessage")
[17:29:41.741]                       }
[17:29:41.741]                       else if (inherits(cond, "warning")) {
[17:29:41.741]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.741]                         if (muffled) 
[17:29:41.741]                           invokeRestart("muffleWarning")
[17:29:41.741]                       }
[17:29:41.741]                       else if (inherits(cond, "condition")) {
[17:29:41.741]                         if (!is.null(pattern)) {
[17:29:41.741]                           computeRestarts <- base::computeRestarts
[17:29:41.741]                           grepl <- base::grepl
[17:29:41.741]                           restarts <- computeRestarts(cond)
[17:29:41.741]                           for (restart in restarts) {
[17:29:41.741]                             name <- restart$name
[17:29:41.741]                             if (is.null(name)) 
[17:29:41.741]                               next
[17:29:41.741]                             if (!grepl(pattern, name)) 
[17:29:41.741]                               next
[17:29:41.741]                             invokeRestart(restart)
[17:29:41.741]                             muffled <- TRUE
[17:29:41.741]                             break
[17:29:41.741]                           }
[17:29:41.741]                         }
[17:29:41.741]                       }
[17:29:41.741]                       invisible(muffled)
[17:29:41.741]                     }
[17:29:41.741]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.741]                   }
[17:29:41.741]                 }
[17:29:41.741]             }
[17:29:41.741]         }))
[17:29:41.741]     }, error = function(ex) {
[17:29:41.741]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.741]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.741]                 ...future.rng), started = ...future.startTime, 
[17:29:41.741]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.741]             version = "1.8"), class = "FutureResult")
[17:29:41.741]     }, finally = {
[17:29:41.741]         if (!identical(...future.workdir, getwd())) 
[17:29:41.741]             setwd(...future.workdir)
[17:29:41.741]         {
[17:29:41.741]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.741]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.741]             }
[17:29:41.741]             base::options(...future.oldOptions)
[17:29:41.741]             if (.Platform$OS.type == "windows") {
[17:29:41.741]                 old_names <- names(...future.oldEnvVars)
[17:29:41.741]                 envs <- base::Sys.getenv()
[17:29:41.741]                 names <- names(envs)
[17:29:41.741]                 common <- intersect(names, old_names)
[17:29:41.741]                 added <- setdiff(names, old_names)
[17:29:41.741]                 removed <- setdiff(old_names, names)
[17:29:41.741]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.741]                   envs[common]]
[17:29:41.741]                 NAMES <- toupper(changed)
[17:29:41.741]                 args <- list()
[17:29:41.741]                 for (kk in seq_along(NAMES)) {
[17:29:41.741]                   name <- changed[[kk]]
[17:29:41.741]                   NAME <- NAMES[[kk]]
[17:29:41.741]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.741]                     next
[17:29:41.741]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.741]                 }
[17:29:41.741]                 NAMES <- toupper(added)
[17:29:41.741]                 for (kk in seq_along(NAMES)) {
[17:29:41.741]                   name <- added[[kk]]
[17:29:41.741]                   NAME <- NAMES[[kk]]
[17:29:41.741]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.741]                     next
[17:29:41.741]                   args[[name]] <- ""
[17:29:41.741]                 }
[17:29:41.741]                 NAMES <- toupper(removed)
[17:29:41.741]                 for (kk in seq_along(NAMES)) {
[17:29:41.741]                   name <- removed[[kk]]
[17:29:41.741]                   NAME <- NAMES[[kk]]
[17:29:41.741]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.741]                     next
[17:29:41.741]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.741]                 }
[17:29:41.741]                 if (length(args) > 0) 
[17:29:41.741]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.741]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.741]             }
[17:29:41.741]             else {
[17:29:41.741]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.741]             }
[17:29:41.741]             {
[17:29:41.741]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.741]                   0L) {
[17:29:41.741]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.741]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.741]                   base::options(opts)
[17:29:41.741]                 }
[17:29:41.741]                 {
[17:29:41.741]                   {
[17:29:41.741]                     base::assign(".Random.seed", c(10407L, 1936438221L, 
[17:29:41.741]                     1829792224L, 2146401322L, -72351411L, -1184524314L, 
[17:29:41.741]                     -1340892671L), envir = base::globalenv(), 
[17:29:41.741]                       inherits = FALSE)
[17:29:41.741]                     NULL
[17:29:41.741]                   }
[17:29:41.741]                   options(future.plan = NULL)
[17:29:41.741]                   if (is.na(NA_character_)) 
[17:29:41.741]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.741]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.741]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.741]                     .init = FALSE)
[17:29:41.741]                 }
[17:29:41.741]             }
[17:29:41.741]         }
[17:29:41.741]     })
[17:29:41.741]     if (TRUE) {
[17:29:41.741]         base::sink(type = "output", split = FALSE)
[17:29:41.741]         if (TRUE) {
[17:29:41.741]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.741]         }
[17:29:41.741]         else {
[17:29:41.741]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.741]         }
[17:29:41.741]         base::close(...future.stdout)
[17:29:41.741]         ...future.stdout <- NULL
[17:29:41.741]     }
[17:29:41.741]     ...future.result$conditions <- ...future.conditions
[17:29:41.741]     ...future.result$finished <- base::Sys.time()
[17:29:41.741]     ...future.result
[17:29:41.741] }
[17:29:41.745] assign_globals() ...
[17:29:41.747] List of 1
[17:29:41.747]  $ x: int [1:4] 0 1 2 3
[17:29:41.747]  - attr(*, "where")=List of 1
[17:29:41.747]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.747]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.747]  - attr(*, "resolved")= logi FALSE
[17:29:41.747]  - attr(*, "total_size")= int 133
[17:29:41.747]  - attr(*, "already-done")= logi TRUE
[17:29:41.752] - copied 'x' to environment
[17:29:41.752] assign_globals() ... done
[17:29:41.753] plan(): Setting new future strategy stack:
[17:29:41.753] List of future strategies:
[17:29:41.753] 1. sequential:
[17:29:41.753]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.753]    - tweaked: FALSE
[17:29:41.753]    - call: NULL
[17:29:41.754] plan(): nbrOfWorkers() = 1
[17:29:41.756] plan(): Setting new future strategy stack:
[17:29:41.756] List of future strategies:
[17:29:41.756] 1. sequential:
[17:29:41.756]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.756]    - tweaked: FALSE
[17:29:41.756]    - call: plan(strategy)
[17:29:41.757] plan(): nbrOfWorkers() = 1
[17:29:41.758] SequentialFuture started (and completed)
[17:29:41.758] - Launch lazy future ... done
[17:29:41.758] run() for 'SequentialFuture' ... done
SequentialFuture:
Label: 'fsample_4-708572'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add712c8f0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.760] resolve() on list ...
[17:29:41.760]  recursive: 0
[17:29:41.761]  length: 4
[17:29:41.761] 
[17:29:41.761] resolved() for 'SequentialFuture' ...
[17:29:41.762] - state: 'finished'
[17:29:41.762] - run: TRUE
[17:29:41.762] - result: 'FutureResult'
[17:29:41.763] resolved() for 'SequentialFuture' ... done
[17:29:41.763] Future #1
[17:29:41.763] signalConditionsASAP(SequentialFuture, pos=1) ...
[17:29:41.764] - nx: 4
[17:29:41.764] - relay: TRUE
[17:29:41.764] - stdout: TRUE
[17:29:41.765] - signal: TRUE
[17:29:41.765] - resignal: FALSE
[17:29:41.765] - force: TRUE
[17:29:41.765] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:41.765] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:41.766]  - until=1
[17:29:41.766]  - relaying element #1
[17:29:41.767] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:41.767] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:41.767] signalConditionsASAP(SequentialFuture, pos=1) ... done
[17:29:41.768]  length: 3 (resolved future 1)
[17:29:41.768] resolved() for 'SequentialFuture' ...
[17:29:41.768] - state: 'finished'
[17:29:41.769] - run: TRUE
[17:29:41.769] - result: 'FutureResult'
[17:29:41.769] resolved() for 'SequentialFuture' ... done
[17:29:41.770] Future #2
[17:29:41.770] signalConditionsASAP(SequentialFuture, pos=2) ...
[17:29:41.770] - nx: 4
[17:29:41.771] - relay: TRUE
[17:29:41.771] - stdout: TRUE
[17:29:41.771] - signal: TRUE
[17:29:41.771] - resignal: FALSE
[17:29:41.772] - force: TRUE
[17:29:41.772] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:41.772] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:41.773]  - until=2
[17:29:41.773]  - relaying element #2
[17:29:41.773] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:41.774] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:41.774] signalConditionsASAP(SequentialFuture, pos=2) ... done
[17:29:41.774]  length: 2 (resolved future 2)
[17:29:41.775] resolved() for 'SequentialFuture' ...
[17:29:41.775] - state: 'finished'
[17:29:41.775] - run: TRUE
[17:29:41.776] - result: 'FutureResult'
[17:29:41.776] resolved() for 'SequentialFuture' ... done
[17:29:41.776] Future #3
[17:29:41.777] signalConditionsASAP(SequentialFuture, pos=3) ...
[17:29:41.777] - nx: 4
[17:29:41.777] - relay: TRUE
[17:29:41.778] - stdout: TRUE
[17:29:41.778] - signal: TRUE
[17:29:41.778] - resignal: FALSE
[17:29:41.778] - force: TRUE
[17:29:41.779] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:41.779] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:41.779]  - until=3
[17:29:41.780]  - relaying element #3
[17:29:41.780] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:41.780] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:41.781] signalConditionsASAP(SequentialFuture, pos=3) ... done
[17:29:41.781]  length: 1 (resolved future 3)
[17:29:41.781] resolved() for 'SequentialFuture' ...
[17:29:41.782] - state: 'finished'
[17:29:41.782] - run: TRUE
[17:29:41.782] - result: 'FutureResult'
[17:29:41.783] resolved() for 'SequentialFuture' ... done
[17:29:41.783] Future #4
[17:29:41.783] signalConditionsASAP(SequentialFuture, pos=4) ...
[17:29:41.784] - nx: 4
[17:29:41.784] - relay: TRUE
[17:29:41.784] - stdout: TRUE
[17:29:41.785] - signal: TRUE
[17:29:41.785] - resignal: FALSE
[17:29:41.785] - force: TRUE
[17:29:41.785] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:41.786] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:41.786]  - until=4
[17:29:41.786]  - relaying element #4
[17:29:41.787] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:41.787] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:41.788] signalConditionsASAP(SequentialFuture, pos=4) ... done
[17:29:41.788]  length: 0 (resolved future 4)
[17:29:41.788] Relaying remaining futures
[17:29:41.788] signalConditionsASAP(NULL, pos=0) ...
[17:29:41.789] - nx: 4
[17:29:41.789] - relay: TRUE
[17:29:41.789] - stdout: TRUE
[17:29:41.790] - signal: TRUE
[17:29:41.790] - resignal: FALSE
[17:29:41.790] - force: TRUE
[17:29:41.790] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:41.791] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:29:41.791] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:41.791] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:41.792] signalConditionsASAP(NULL, pos=0) ... done
[17:29:41.792] resolve() on list ... DONE
[[1]]
[1] 0

[[2]]
[1] 3

[[3]]
[1] 2

[[4]]
[1] 2

[17:29:41.798] getGlobalsAndPackages() ...
[17:29:41.798] Searching for globals...
[17:29:41.800] - globals found: [3] '{', 'sample', 'x'
[17:29:41.801] Searching for globals ... DONE
[17:29:41.801] Resolving globals: FALSE
[17:29:41.802] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.802] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.803] - globals: [1] 'x'
[17:29:41.803] 
[17:29:41.803] getGlobalsAndPackages() ... DONE
[17:29:41.804] run() for 'Future' ...
[17:29:41.804] - state: 'created'
[17:29:41.804] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.805] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.805] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.806]   - Field: 'label'
[17:29:41.806]   - Field: 'local'
[17:29:41.806]   - Field: 'owner'
[17:29:41.806]   - Field: 'envir'
[17:29:41.807]   - Field: 'packages'
[17:29:41.807]   - Field: 'gc'
[17:29:41.807]   - Field: 'conditions'
[17:29:41.807]   - Field: 'expr'
[17:29:41.808]   - Field: 'uuid'
[17:29:41.808]   - Field: 'seed'
[17:29:41.808]   - Field: 'version'
[17:29:41.808]   - Field: 'result'
[17:29:41.808]   - Field: 'asynchronous'
[17:29:41.809]   - Field: 'calls'
[17:29:41.809]   - Field: 'globals'
[17:29:41.809]   - Field: 'stdout'
[17:29:41.809]   - Field: 'earlySignal'
[17:29:41.810]   - Field: 'lazy'
[17:29:41.810]   - Field: 'state'
[17:29:41.810] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.810] - Launch lazy future ...
[17:29:41.811] Packages needed by the future expression (n = 0): <none>
[17:29:41.811] Packages needed by future strategies (n = 0): <none>
[17:29:41.812] {
[17:29:41.812]     {
[17:29:41.812]         {
[17:29:41.812]             ...future.startTime <- base::Sys.time()
[17:29:41.812]             {
[17:29:41.812]                 {
[17:29:41.812]                   {
[17:29:41.812]                     {
[17:29:41.812]                       base::local({
[17:29:41.812]                         has_future <- base::requireNamespace("future", 
[17:29:41.812]                           quietly = TRUE)
[17:29:41.812]                         if (has_future) {
[17:29:41.812]                           ns <- base::getNamespace("future")
[17:29:41.812]                           version <- ns[[".package"]][["version"]]
[17:29:41.812]                           if (is.null(version)) 
[17:29:41.812]                             version <- utils::packageVersion("future")
[17:29:41.812]                         }
[17:29:41.812]                         else {
[17:29:41.812]                           version <- NULL
[17:29:41.812]                         }
[17:29:41.812]                         if (!has_future || version < "1.8.0") {
[17:29:41.812]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.812]                             "", base::R.version$version.string), 
[17:29:41.812]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:41.812]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.812]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.812]                               "release", "version")], collapse = " "), 
[17:29:41.812]                             hostname = base::Sys.info()[["nodename"]])
[17:29:41.812]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.812]                             info)
[17:29:41.812]                           info <- base::paste(info, collapse = "; ")
[17:29:41.812]                           if (!has_future) {
[17:29:41.812]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.812]                               info)
[17:29:41.812]                           }
[17:29:41.812]                           else {
[17:29:41.812]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.812]                               info, version)
[17:29:41.812]                           }
[17:29:41.812]                           base::stop(msg)
[17:29:41.812]                         }
[17:29:41.812]                       })
[17:29:41.812]                     }
[17:29:41.812]                     ...future.strategy.old <- future::plan("list")
[17:29:41.812]                     options(future.plan = NULL)
[17:29:41.812]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.812]                     future::plan("default", .cleanup = FALSE, 
[17:29:41.812]                       .init = FALSE)
[17:29:41.812]                   }
[17:29:41.812]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[17:29:41.812]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[17:29:41.812]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[17:29:41.812]                 }
[17:29:41.812]                 ...future.workdir <- getwd()
[17:29:41.812]             }
[17:29:41.812]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.812]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.812]         }
[17:29:41.812]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.812]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.812]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.812]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.812]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.812]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.812]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.812]             base::names(...future.oldOptions))
[17:29:41.812]     }
[17:29:41.812]     if (FALSE) {
[17:29:41.812]     }
[17:29:41.812]     else {
[17:29:41.812]         if (TRUE) {
[17:29:41.812]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.812]                 open = "w")
[17:29:41.812]         }
[17:29:41.812]         else {
[17:29:41.812]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.812]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.812]         }
[17:29:41.812]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.812]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.812]             base::sink(type = "output", split = FALSE)
[17:29:41.812]             base::close(...future.stdout)
[17:29:41.812]         }, add = TRUE)
[17:29:41.812]     }
[17:29:41.812]     ...future.frame <- base::sys.nframe()
[17:29:41.812]     ...future.conditions <- base::list()
[17:29:41.812]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.812]     if (FALSE) {
[17:29:41.812]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.812]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.812]     }
[17:29:41.812]     ...future.result <- base::tryCatch({
[17:29:41.812]         base::withCallingHandlers({
[17:29:41.812]             ...future.value <- base::withVisible(base::local({
[17:29:41.812]                 sample(x, size = 1L)
[17:29:41.812]             }))
[17:29:41.812]             future::FutureResult(value = ...future.value$value, 
[17:29:41.812]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.812]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.812]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.812]                     ...future.globalenv.names))
[17:29:41.812]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.812]         }, condition = base::local({
[17:29:41.812]             c <- base::c
[17:29:41.812]             inherits <- base::inherits
[17:29:41.812]             invokeRestart <- base::invokeRestart
[17:29:41.812]             length <- base::length
[17:29:41.812]             list <- base::list
[17:29:41.812]             seq.int <- base::seq.int
[17:29:41.812]             signalCondition <- base::signalCondition
[17:29:41.812]             sys.calls <- base::sys.calls
[17:29:41.812]             `[[` <- base::`[[`
[17:29:41.812]             `+` <- base::`+`
[17:29:41.812]             `<<-` <- base::`<<-`
[17:29:41.812]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.812]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.812]                   3L)]
[17:29:41.812]             }
[17:29:41.812]             function(cond) {
[17:29:41.812]                 is_error <- inherits(cond, "error")
[17:29:41.812]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.812]                   NULL)
[17:29:41.812]                 if (is_error) {
[17:29:41.812]                   sessionInformation <- function() {
[17:29:41.812]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.812]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.812]                       search = base::search(), system = base::Sys.info())
[17:29:41.812]                   }
[17:29:41.812]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.812]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.812]                     cond$call), session = sessionInformation(), 
[17:29:41.812]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.812]                   signalCondition(cond)
[17:29:41.812]                 }
[17:29:41.812]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.812]                 "immediateCondition"))) {
[17:29:41.812]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.812]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.812]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.812]                   if (TRUE && !signal) {
[17:29:41.812]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.812]                     {
[17:29:41.812]                       inherits <- base::inherits
[17:29:41.812]                       invokeRestart <- base::invokeRestart
[17:29:41.812]                       is.null <- base::is.null
[17:29:41.812]                       muffled <- FALSE
[17:29:41.812]                       if (inherits(cond, "message")) {
[17:29:41.812]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.812]                         if (muffled) 
[17:29:41.812]                           invokeRestart("muffleMessage")
[17:29:41.812]                       }
[17:29:41.812]                       else if (inherits(cond, "warning")) {
[17:29:41.812]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.812]                         if (muffled) 
[17:29:41.812]                           invokeRestart("muffleWarning")
[17:29:41.812]                       }
[17:29:41.812]                       else if (inherits(cond, "condition")) {
[17:29:41.812]                         if (!is.null(pattern)) {
[17:29:41.812]                           computeRestarts <- base::computeRestarts
[17:29:41.812]                           grepl <- base::grepl
[17:29:41.812]                           restarts <- computeRestarts(cond)
[17:29:41.812]                           for (restart in restarts) {
[17:29:41.812]                             name <- restart$name
[17:29:41.812]                             if (is.null(name)) 
[17:29:41.812]                               next
[17:29:41.812]                             if (!grepl(pattern, name)) 
[17:29:41.812]                               next
[17:29:41.812]                             invokeRestart(restart)
[17:29:41.812]                             muffled <- TRUE
[17:29:41.812]                             break
[17:29:41.812]                           }
[17:29:41.812]                         }
[17:29:41.812]                       }
[17:29:41.812]                       invisible(muffled)
[17:29:41.812]                     }
[17:29:41.812]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.812]                   }
[17:29:41.812]                 }
[17:29:41.812]                 else {
[17:29:41.812]                   if (TRUE) {
[17:29:41.812]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.812]                     {
[17:29:41.812]                       inherits <- base::inherits
[17:29:41.812]                       invokeRestart <- base::invokeRestart
[17:29:41.812]                       is.null <- base::is.null
[17:29:41.812]                       muffled <- FALSE
[17:29:41.812]                       if (inherits(cond, "message")) {
[17:29:41.812]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.812]                         if (muffled) 
[17:29:41.812]                           invokeRestart("muffleMessage")
[17:29:41.812]                       }
[17:29:41.812]                       else if (inherits(cond, "warning")) {
[17:29:41.812]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.812]                         if (muffled) 
[17:29:41.812]                           invokeRestart("muffleWarning")
[17:29:41.812]                       }
[17:29:41.812]                       else if (inherits(cond, "condition")) {
[17:29:41.812]                         if (!is.null(pattern)) {
[17:29:41.812]                           computeRestarts <- base::computeRestarts
[17:29:41.812]                           grepl <- base::grepl
[17:29:41.812]                           restarts <- computeRestarts(cond)
[17:29:41.812]                           for (restart in restarts) {
[17:29:41.812]                             name <- restart$name
[17:29:41.812]                             if (is.null(name)) 
[17:29:41.812]                               next
[17:29:41.812]                             if (!grepl(pattern, name)) 
[17:29:41.812]                               next
[17:29:41.812]                             invokeRestart(restart)
[17:29:41.812]                             muffled <- TRUE
[17:29:41.812]                             break
[17:29:41.812]                           }
[17:29:41.812]                         }
[17:29:41.812]                       }
[17:29:41.812]                       invisible(muffled)
[17:29:41.812]                     }
[17:29:41.812]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.812]                   }
[17:29:41.812]                 }
[17:29:41.812]             }
[17:29:41.812]         }))
[17:29:41.812]     }, error = function(ex) {
[17:29:41.812]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.812]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.812]                 ...future.rng), started = ...future.startTime, 
[17:29:41.812]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.812]             version = "1.8"), class = "FutureResult")
[17:29:41.812]     }, finally = {
[17:29:41.812]         if (!identical(...future.workdir, getwd())) 
[17:29:41.812]             setwd(...future.workdir)
[17:29:41.812]         {
[17:29:41.812]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.812]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.812]             }
[17:29:41.812]             base::options(...future.oldOptions)
[17:29:41.812]             if (.Platform$OS.type == "windows") {
[17:29:41.812]                 old_names <- names(...future.oldEnvVars)
[17:29:41.812]                 envs <- base::Sys.getenv()
[17:29:41.812]                 names <- names(envs)
[17:29:41.812]                 common <- intersect(names, old_names)
[17:29:41.812]                 added <- setdiff(names, old_names)
[17:29:41.812]                 removed <- setdiff(old_names, names)
[17:29:41.812]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.812]                   envs[common]]
[17:29:41.812]                 NAMES <- toupper(changed)
[17:29:41.812]                 args <- list()
[17:29:41.812]                 for (kk in seq_along(NAMES)) {
[17:29:41.812]                   name <- changed[[kk]]
[17:29:41.812]                   NAME <- NAMES[[kk]]
[17:29:41.812]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.812]                     next
[17:29:41.812]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.812]                 }
[17:29:41.812]                 NAMES <- toupper(added)
[17:29:41.812]                 for (kk in seq_along(NAMES)) {
[17:29:41.812]                   name <- added[[kk]]
[17:29:41.812]                   NAME <- NAMES[[kk]]
[17:29:41.812]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.812]                     next
[17:29:41.812]                   args[[name]] <- ""
[17:29:41.812]                 }
[17:29:41.812]                 NAMES <- toupper(removed)
[17:29:41.812]                 for (kk in seq_along(NAMES)) {
[17:29:41.812]                   name <- removed[[kk]]
[17:29:41.812]                   NAME <- NAMES[[kk]]
[17:29:41.812]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.812]                     next
[17:29:41.812]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.812]                 }
[17:29:41.812]                 if (length(args) > 0) 
[17:29:41.812]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.812]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.812]             }
[17:29:41.812]             else {
[17:29:41.812]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.812]             }
[17:29:41.812]             {
[17:29:41.812]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.812]                   0L) {
[17:29:41.812]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.812]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.812]                   base::options(opts)
[17:29:41.812]                 }
[17:29:41.812]                 {
[17:29:41.812]                   {
[17:29:41.812]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:41.812]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:41.812]                     -1344458670L), envir = base::globalenv(), 
[17:29:41.812]                       inherits = FALSE)
[17:29:41.812]                     NULL
[17:29:41.812]                   }
[17:29:41.812]                   options(future.plan = NULL)
[17:29:41.812]                   if (is.na(NA_character_)) 
[17:29:41.812]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.812]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.812]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.812]                     .init = FALSE)
[17:29:41.812]                 }
[17:29:41.812]             }
[17:29:41.812]         }
[17:29:41.812]     })
[17:29:41.812]     if (TRUE) {
[17:29:41.812]         base::sink(type = "output", split = FALSE)
[17:29:41.812]         if (TRUE) {
[17:29:41.812]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.812]         }
[17:29:41.812]         else {
[17:29:41.812]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.812]         }
[17:29:41.812]         base::close(...future.stdout)
[17:29:41.812]         ...future.stdout <- NULL
[17:29:41.812]     }
[17:29:41.812]     ...future.result$conditions <- ...future.conditions
[17:29:41.812]     ...future.result$finished <- base::Sys.time()
[17:29:41.812]     ...future.result
[17:29:41.812] }
[17:29:41.818] assign_globals() ...
[17:29:41.818] List of 1
[17:29:41.818]  $ x: int [1:4] 0 1 2 3
[17:29:41.818]  - attr(*, "where")=List of 1
[17:29:41.818]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.818]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.818]  - attr(*, "resolved")= logi FALSE
[17:29:41.818]  - attr(*, "total_size")= int 133
[17:29:41.818]  - attr(*, "already-done")= logi TRUE
[17:29:41.823] - copied 'x' to environment
[17:29:41.824] assign_globals() ... done
[17:29:41.824] plan(): Setting new future strategy stack:
[17:29:41.825] List of future strategies:
[17:29:41.825] 1. sequential:
[17:29:41.825]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.825]    - tweaked: FALSE
[17:29:41.825]    - call: NULL
[17:29:41.826] plan(): nbrOfWorkers() = 1
[17:29:41.828] plan(): Setting new future strategy stack:
[17:29:41.828] List of future strategies:
[17:29:41.828] 1. sequential:
[17:29:41.828]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.828]    - tweaked: FALSE
[17:29:41.828]    - call: plan(strategy)
[17:29:41.829] plan(): nbrOfWorkers() = 1
[17:29:41.829] SequentialFuture started (and completed)
[17:29:41.830] - Launch lazy future ... done
[17:29:41.830] run() for 'SequentialFuture' ... done
[17:29:41.831] getGlobalsAndPackages() ...
[17:29:41.831] Searching for globals...
[17:29:41.833] - globals found: [3] '{', 'sample', 'x'
[17:29:41.834] Searching for globals ... DONE
[17:29:41.834] Resolving globals: FALSE
[17:29:41.835] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.836] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.836] - globals: [1] 'x'
[17:29:41.836] 
[17:29:41.836] getGlobalsAndPackages() ... DONE
[17:29:41.837] run() for 'Future' ...
[17:29:41.837] - state: 'created'
[17:29:41.838] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.839] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.839] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.839]   - Field: 'label'
[17:29:41.840]   - Field: 'local'
[17:29:41.840]   - Field: 'owner'
[17:29:41.840]   - Field: 'envir'
[17:29:41.840]   - Field: 'packages'
[17:29:41.841]   - Field: 'gc'
[17:29:41.841]   - Field: 'conditions'
[17:29:41.841]   - Field: 'expr'
[17:29:41.842]   - Field: 'uuid'
[17:29:41.842]   - Field: 'seed'
[17:29:41.842]   - Field: 'version'
[17:29:41.843]   - Field: 'result'
[17:29:41.846]   - Field: 'asynchronous'
[17:29:41.846]   - Field: 'calls'
[17:29:41.846]   - Field: 'globals'
[17:29:41.847]   - Field: 'stdout'
[17:29:41.847]   - Field: 'earlySignal'
[17:29:41.848]   - Field: 'lazy'
[17:29:41.848]   - Field: 'state'
[17:29:41.848] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.849] - Launch lazy future ...
[17:29:41.849] Packages needed by the future expression (n = 0): <none>
[17:29:41.849] Packages needed by future strategies (n = 0): <none>
[17:29:41.850] {
[17:29:41.850]     {
[17:29:41.850]         {
[17:29:41.850]             ...future.startTime <- base::Sys.time()
[17:29:41.850]             {
[17:29:41.850]                 {
[17:29:41.850]                   {
[17:29:41.850]                     {
[17:29:41.850]                       base::local({
[17:29:41.850]                         has_future <- base::requireNamespace("future", 
[17:29:41.850]                           quietly = TRUE)
[17:29:41.850]                         if (has_future) {
[17:29:41.850]                           ns <- base::getNamespace("future")
[17:29:41.850]                           version <- ns[[".package"]][["version"]]
[17:29:41.850]                           if (is.null(version)) 
[17:29:41.850]                             version <- utils::packageVersion("future")
[17:29:41.850]                         }
[17:29:41.850]                         else {
[17:29:41.850]                           version <- NULL
[17:29:41.850]                         }
[17:29:41.850]                         if (!has_future || version < "1.8.0") {
[17:29:41.850]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.850]                             "", base::R.version$version.string), 
[17:29:41.850]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:41.850]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.850]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.850]                               "release", "version")], collapse = " "), 
[17:29:41.850]                             hostname = base::Sys.info()[["nodename"]])
[17:29:41.850]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.850]                             info)
[17:29:41.850]                           info <- base::paste(info, collapse = "; ")
[17:29:41.850]                           if (!has_future) {
[17:29:41.850]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.850]                               info)
[17:29:41.850]                           }
[17:29:41.850]                           else {
[17:29:41.850]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.850]                               info, version)
[17:29:41.850]                           }
[17:29:41.850]                           base::stop(msg)
[17:29:41.850]                         }
[17:29:41.850]                       })
[17:29:41.850]                     }
[17:29:41.850]                     ...future.strategy.old <- future::plan("list")
[17:29:41.850]                     options(future.plan = NULL)
[17:29:41.850]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.850]                     future::plan("default", .cleanup = FALSE, 
[17:29:41.850]                       .init = FALSE)
[17:29:41.850]                   }
[17:29:41.850]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[17:29:41.850]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[17:29:41.850]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[17:29:41.850]                 }
[17:29:41.850]                 ...future.workdir <- getwd()
[17:29:41.850]             }
[17:29:41.850]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.850]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.850]         }
[17:29:41.850]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.850]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.850]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.850]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.850]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.850]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.850]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.850]             base::names(...future.oldOptions))
[17:29:41.850]     }
[17:29:41.850]     if (FALSE) {
[17:29:41.850]     }
[17:29:41.850]     else {
[17:29:41.850]         if (TRUE) {
[17:29:41.850]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.850]                 open = "w")
[17:29:41.850]         }
[17:29:41.850]         else {
[17:29:41.850]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.850]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.850]         }
[17:29:41.850]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.850]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.850]             base::sink(type = "output", split = FALSE)
[17:29:41.850]             base::close(...future.stdout)
[17:29:41.850]         }, add = TRUE)
[17:29:41.850]     }
[17:29:41.850]     ...future.frame <- base::sys.nframe()
[17:29:41.850]     ...future.conditions <- base::list()
[17:29:41.850]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.850]     if (FALSE) {
[17:29:41.850]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.850]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.850]     }
[17:29:41.850]     ...future.result <- base::tryCatch({
[17:29:41.850]         base::withCallingHandlers({
[17:29:41.850]             ...future.value <- base::withVisible(base::local({
[17:29:41.850]                 sample(x, size = 1L)
[17:29:41.850]             }))
[17:29:41.850]             future::FutureResult(value = ...future.value$value, 
[17:29:41.850]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.850]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.850]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.850]                     ...future.globalenv.names))
[17:29:41.850]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.850]         }, condition = base::local({
[17:29:41.850]             c <- base::c
[17:29:41.850]             inherits <- base::inherits
[17:29:41.850]             invokeRestart <- base::invokeRestart
[17:29:41.850]             length <- base::length
[17:29:41.850]             list <- base::list
[17:29:41.850]             seq.int <- base::seq.int
[17:29:41.850]             signalCondition <- base::signalCondition
[17:29:41.850]             sys.calls <- base::sys.calls
[17:29:41.850]             `[[` <- base::`[[`
[17:29:41.850]             `+` <- base::`+`
[17:29:41.850]             `<<-` <- base::`<<-`
[17:29:41.850]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.850]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.850]                   3L)]
[17:29:41.850]             }
[17:29:41.850]             function(cond) {
[17:29:41.850]                 is_error <- inherits(cond, "error")
[17:29:41.850]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.850]                   NULL)
[17:29:41.850]                 if (is_error) {
[17:29:41.850]                   sessionInformation <- function() {
[17:29:41.850]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.850]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.850]                       search = base::search(), system = base::Sys.info())
[17:29:41.850]                   }
[17:29:41.850]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.850]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.850]                     cond$call), session = sessionInformation(), 
[17:29:41.850]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.850]                   signalCondition(cond)
[17:29:41.850]                 }
[17:29:41.850]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.850]                 "immediateCondition"))) {
[17:29:41.850]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.850]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.850]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.850]                   if (TRUE && !signal) {
[17:29:41.850]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.850]                     {
[17:29:41.850]                       inherits <- base::inherits
[17:29:41.850]                       invokeRestart <- base::invokeRestart
[17:29:41.850]                       is.null <- base::is.null
[17:29:41.850]                       muffled <- FALSE
[17:29:41.850]                       if (inherits(cond, "message")) {
[17:29:41.850]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.850]                         if (muffled) 
[17:29:41.850]                           invokeRestart("muffleMessage")
[17:29:41.850]                       }
[17:29:41.850]                       else if (inherits(cond, "warning")) {
[17:29:41.850]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.850]                         if (muffled) 
[17:29:41.850]                           invokeRestart("muffleWarning")
[17:29:41.850]                       }
[17:29:41.850]                       else if (inherits(cond, "condition")) {
[17:29:41.850]                         if (!is.null(pattern)) {
[17:29:41.850]                           computeRestarts <- base::computeRestarts
[17:29:41.850]                           grepl <- base::grepl
[17:29:41.850]                           restarts <- computeRestarts(cond)
[17:29:41.850]                           for (restart in restarts) {
[17:29:41.850]                             name <- restart$name
[17:29:41.850]                             if (is.null(name)) 
[17:29:41.850]                               next
[17:29:41.850]                             if (!grepl(pattern, name)) 
[17:29:41.850]                               next
[17:29:41.850]                             invokeRestart(restart)
[17:29:41.850]                             muffled <- TRUE
[17:29:41.850]                             break
[17:29:41.850]                           }
[17:29:41.850]                         }
[17:29:41.850]                       }
[17:29:41.850]                       invisible(muffled)
[17:29:41.850]                     }
[17:29:41.850]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.850]                   }
[17:29:41.850]                 }
[17:29:41.850]                 else {
[17:29:41.850]                   if (TRUE) {
[17:29:41.850]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.850]                     {
[17:29:41.850]                       inherits <- base::inherits
[17:29:41.850]                       invokeRestart <- base::invokeRestart
[17:29:41.850]                       is.null <- base::is.null
[17:29:41.850]                       muffled <- FALSE
[17:29:41.850]                       if (inherits(cond, "message")) {
[17:29:41.850]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.850]                         if (muffled) 
[17:29:41.850]                           invokeRestart("muffleMessage")
[17:29:41.850]                       }
[17:29:41.850]                       else if (inherits(cond, "warning")) {
[17:29:41.850]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.850]                         if (muffled) 
[17:29:41.850]                           invokeRestart("muffleWarning")
[17:29:41.850]                       }
[17:29:41.850]                       else if (inherits(cond, "condition")) {
[17:29:41.850]                         if (!is.null(pattern)) {
[17:29:41.850]                           computeRestarts <- base::computeRestarts
[17:29:41.850]                           grepl <- base::grepl
[17:29:41.850]                           restarts <- computeRestarts(cond)
[17:29:41.850]                           for (restart in restarts) {
[17:29:41.850]                             name <- restart$name
[17:29:41.850]                             if (is.null(name)) 
[17:29:41.850]                               next
[17:29:41.850]                             if (!grepl(pattern, name)) 
[17:29:41.850]                               next
[17:29:41.850]                             invokeRestart(restart)
[17:29:41.850]                             muffled <- TRUE
[17:29:41.850]                             break
[17:29:41.850]                           }
[17:29:41.850]                         }
[17:29:41.850]                       }
[17:29:41.850]                       invisible(muffled)
[17:29:41.850]                     }
[17:29:41.850]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.850]                   }
[17:29:41.850]                 }
[17:29:41.850]             }
[17:29:41.850]         }))
[17:29:41.850]     }, error = function(ex) {
[17:29:41.850]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.850]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.850]                 ...future.rng), started = ...future.startTime, 
[17:29:41.850]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.850]             version = "1.8"), class = "FutureResult")
[17:29:41.850]     }, finally = {
[17:29:41.850]         if (!identical(...future.workdir, getwd())) 
[17:29:41.850]             setwd(...future.workdir)
[17:29:41.850]         {
[17:29:41.850]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.850]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.850]             }
[17:29:41.850]             base::options(...future.oldOptions)
[17:29:41.850]             if (.Platform$OS.type == "windows") {
[17:29:41.850]                 old_names <- names(...future.oldEnvVars)
[17:29:41.850]                 envs <- base::Sys.getenv()
[17:29:41.850]                 names <- names(envs)
[17:29:41.850]                 common <- intersect(names, old_names)
[17:29:41.850]                 added <- setdiff(names, old_names)
[17:29:41.850]                 removed <- setdiff(old_names, names)
[17:29:41.850]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.850]                   envs[common]]
[17:29:41.850]                 NAMES <- toupper(changed)
[17:29:41.850]                 args <- list()
[17:29:41.850]                 for (kk in seq_along(NAMES)) {
[17:29:41.850]                   name <- changed[[kk]]
[17:29:41.850]                   NAME <- NAMES[[kk]]
[17:29:41.850]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.850]                     next
[17:29:41.850]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.850]                 }
[17:29:41.850]                 NAMES <- toupper(added)
[17:29:41.850]                 for (kk in seq_along(NAMES)) {
[17:29:41.850]                   name <- added[[kk]]
[17:29:41.850]                   NAME <- NAMES[[kk]]
[17:29:41.850]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.850]                     next
[17:29:41.850]                   args[[name]] <- ""
[17:29:41.850]                 }
[17:29:41.850]                 NAMES <- toupper(removed)
[17:29:41.850]                 for (kk in seq_along(NAMES)) {
[17:29:41.850]                   name <- removed[[kk]]
[17:29:41.850]                   NAME <- NAMES[[kk]]
[17:29:41.850]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.850]                     next
[17:29:41.850]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.850]                 }
[17:29:41.850]                 if (length(args) > 0) 
[17:29:41.850]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.850]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.850]             }
[17:29:41.850]             else {
[17:29:41.850]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.850]             }
[17:29:41.850]             {
[17:29:41.850]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.850]                   0L) {
[17:29:41.850]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.850]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.850]                   base::options(opts)
[17:29:41.850]                 }
[17:29:41.850]                 {
[17:29:41.850]                   {
[17:29:41.850]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:41.850]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:41.850]                     -1344458670L), envir = base::globalenv(), 
[17:29:41.850]                       inherits = FALSE)
[17:29:41.850]                     NULL
[17:29:41.850]                   }
[17:29:41.850]                   options(future.plan = NULL)
[17:29:41.850]                   if (is.na(NA_character_)) 
[17:29:41.850]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.850]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.850]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.850]                     .init = FALSE)
[17:29:41.850]                 }
[17:29:41.850]             }
[17:29:41.850]         }
[17:29:41.850]     })
[17:29:41.850]     if (TRUE) {
[17:29:41.850]         base::sink(type = "output", split = FALSE)
[17:29:41.850]         if (TRUE) {
[17:29:41.850]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.850]         }
[17:29:41.850]         else {
[17:29:41.850]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.850]         }
[17:29:41.850]         base::close(...future.stdout)
[17:29:41.850]         ...future.stdout <- NULL
[17:29:41.850]     }
[17:29:41.850]     ...future.result$conditions <- ...future.conditions
[17:29:41.850]     ...future.result$finished <- base::Sys.time()
[17:29:41.850]     ...future.result
[17:29:41.850] }
[17:29:41.857] assign_globals() ...
[17:29:41.857] List of 1
[17:29:41.857]  $ x: int [1:4] 0 1 2 3
[17:29:41.857]  - attr(*, "where")=List of 1
[17:29:41.857]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.857]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.857]  - attr(*, "resolved")= logi FALSE
[17:29:41.857]  - attr(*, "total_size")= int 133
[17:29:41.857]  - attr(*, "already-done")= logi TRUE
[17:29:41.862] - copied 'x' to environment
[17:29:41.863] assign_globals() ... done
[17:29:41.863] plan(): Setting new future strategy stack:
[17:29:41.864] List of future strategies:
[17:29:41.864] 1. sequential:
[17:29:41.864]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.864]    - tweaked: FALSE
[17:29:41.864]    - call: NULL
[17:29:41.865] plan(): nbrOfWorkers() = 1
[17:29:41.867] plan(): Setting new future strategy stack:
[17:29:41.867] List of future strategies:
[17:29:41.867] 1. sequential:
[17:29:41.867]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.867]    - tweaked: FALSE
[17:29:41.867]    - call: plan(strategy)
[17:29:41.868] plan(): nbrOfWorkers() = 1
[17:29:41.869] SequentialFuture started (and completed)
[17:29:41.869] - Launch lazy future ... done
[17:29:41.869] run() for 'SequentialFuture' ... done
[17:29:41.870] getGlobalsAndPackages() ...
[17:29:41.870] Searching for globals...
[17:29:41.874] - globals found: [3] '{', 'sample', 'x'
[17:29:41.874] Searching for globals ... DONE
[17:29:41.875] Resolving globals: FALSE
[17:29:41.876] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.876] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.877] - globals: [1] 'x'
[17:29:41.877] 
[17:29:41.877] getGlobalsAndPackages() ... DONE
[17:29:41.878] run() for 'Future' ...
[17:29:41.878] - state: 'created'
[17:29:41.879] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.881] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.881] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.882]   - Field: 'label'
[17:29:41.882]   - Field: 'local'
[17:29:41.882]   - Field: 'owner'
[17:29:41.883]   - Field: 'envir'
[17:29:41.883]   - Field: 'packages'
[17:29:41.883]   - Field: 'gc'
[17:29:41.883]   - Field: 'conditions'
[17:29:41.884]   - Field: 'expr'
[17:29:41.884]   - Field: 'uuid'
[17:29:41.884]   - Field: 'seed'
[17:29:41.885]   - Field: 'version'
[17:29:41.885]   - Field: 'result'
[17:29:41.885]   - Field: 'asynchronous'
[17:29:41.886]   - Field: 'calls'
[17:29:41.886]   - Field: 'globals'
[17:29:41.886]   - Field: 'stdout'
[17:29:41.886]   - Field: 'earlySignal'
[17:29:41.887]   - Field: 'lazy'
[17:29:41.887]   - Field: 'state'
[17:29:41.887] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.888] - Launch lazy future ...
[17:29:41.888] Packages needed by the future expression (n = 0): <none>
[17:29:41.888] Packages needed by future strategies (n = 0): <none>
[17:29:41.889] {
[17:29:41.889]     {
[17:29:41.889]         {
[17:29:41.889]             ...future.startTime <- base::Sys.time()
[17:29:41.889]             {
[17:29:41.889]                 {
[17:29:41.889]                   {
[17:29:41.889]                     {
[17:29:41.889]                       base::local({
[17:29:41.889]                         has_future <- base::requireNamespace("future", 
[17:29:41.889]                           quietly = TRUE)
[17:29:41.889]                         if (has_future) {
[17:29:41.889]                           ns <- base::getNamespace("future")
[17:29:41.889]                           version <- ns[[".package"]][["version"]]
[17:29:41.889]                           if (is.null(version)) 
[17:29:41.889]                             version <- utils::packageVersion("future")
[17:29:41.889]                         }
[17:29:41.889]                         else {
[17:29:41.889]                           version <- NULL
[17:29:41.889]                         }
[17:29:41.889]                         if (!has_future || version < "1.8.0") {
[17:29:41.889]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.889]                             "", base::R.version$version.string), 
[17:29:41.889]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:41.889]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.889]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.889]                               "release", "version")], collapse = " "), 
[17:29:41.889]                             hostname = base::Sys.info()[["nodename"]])
[17:29:41.889]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.889]                             info)
[17:29:41.889]                           info <- base::paste(info, collapse = "; ")
[17:29:41.889]                           if (!has_future) {
[17:29:41.889]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.889]                               info)
[17:29:41.889]                           }
[17:29:41.889]                           else {
[17:29:41.889]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.889]                               info, version)
[17:29:41.889]                           }
[17:29:41.889]                           base::stop(msg)
[17:29:41.889]                         }
[17:29:41.889]                       })
[17:29:41.889]                     }
[17:29:41.889]                     ...future.strategy.old <- future::plan("list")
[17:29:41.889]                     options(future.plan = NULL)
[17:29:41.889]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.889]                     future::plan("default", .cleanup = FALSE, 
[17:29:41.889]                       .init = FALSE)
[17:29:41.889]                   }
[17:29:41.889]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[17:29:41.889]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[17:29:41.889]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[17:29:41.889]                 }
[17:29:41.889]                 ...future.workdir <- getwd()
[17:29:41.889]             }
[17:29:41.889]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.889]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.889]         }
[17:29:41.889]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.889]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.889]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.889]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.889]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.889]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.889]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.889]             base::names(...future.oldOptions))
[17:29:41.889]     }
[17:29:41.889]     if (FALSE) {
[17:29:41.889]     }
[17:29:41.889]     else {
[17:29:41.889]         if (TRUE) {
[17:29:41.889]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.889]                 open = "w")
[17:29:41.889]         }
[17:29:41.889]         else {
[17:29:41.889]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.889]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.889]         }
[17:29:41.889]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.889]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.889]             base::sink(type = "output", split = FALSE)
[17:29:41.889]             base::close(...future.stdout)
[17:29:41.889]         }, add = TRUE)
[17:29:41.889]     }
[17:29:41.889]     ...future.frame <- base::sys.nframe()
[17:29:41.889]     ...future.conditions <- base::list()
[17:29:41.889]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.889]     if (FALSE) {
[17:29:41.889]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.889]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.889]     }
[17:29:41.889]     ...future.result <- base::tryCatch({
[17:29:41.889]         base::withCallingHandlers({
[17:29:41.889]             ...future.value <- base::withVisible(base::local({
[17:29:41.889]                 sample(x, size = 1L)
[17:29:41.889]             }))
[17:29:41.889]             future::FutureResult(value = ...future.value$value, 
[17:29:41.889]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.889]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.889]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.889]                     ...future.globalenv.names))
[17:29:41.889]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.889]         }, condition = base::local({
[17:29:41.889]             c <- base::c
[17:29:41.889]             inherits <- base::inherits
[17:29:41.889]             invokeRestart <- base::invokeRestart
[17:29:41.889]             length <- base::length
[17:29:41.889]             list <- base::list
[17:29:41.889]             seq.int <- base::seq.int
[17:29:41.889]             signalCondition <- base::signalCondition
[17:29:41.889]             sys.calls <- base::sys.calls
[17:29:41.889]             `[[` <- base::`[[`
[17:29:41.889]             `+` <- base::`+`
[17:29:41.889]             `<<-` <- base::`<<-`
[17:29:41.889]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.889]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.889]                   3L)]
[17:29:41.889]             }
[17:29:41.889]             function(cond) {
[17:29:41.889]                 is_error <- inherits(cond, "error")
[17:29:41.889]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.889]                   NULL)
[17:29:41.889]                 if (is_error) {
[17:29:41.889]                   sessionInformation <- function() {
[17:29:41.889]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.889]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.889]                       search = base::search(), system = base::Sys.info())
[17:29:41.889]                   }
[17:29:41.889]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.889]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.889]                     cond$call), session = sessionInformation(), 
[17:29:41.889]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.889]                   signalCondition(cond)
[17:29:41.889]                 }
[17:29:41.889]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.889]                 "immediateCondition"))) {
[17:29:41.889]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.889]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.889]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.889]                   if (TRUE && !signal) {
[17:29:41.889]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.889]                     {
[17:29:41.889]                       inherits <- base::inherits
[17:29:41.889]                       invokeRestart <- base::invokeRestart
[17:29:41.889]                       is.null <- base::is.null
[17:29:41.889]                       muffled <- FALSE
[17:29:41.889]                       if (inherits(cond, "message")) {
[17:29:41.889]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.889]                         if (muffled) 
[17:29:41.889]                           invokeRestart("muffleMessage")
[17:29:41.889]                       }
[17:29:41.889]                       else if (inherits(cond, "warning")) {
[17:29:41.889]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.889]                         if (muffled) 
[17:29:41.889]                           invokeRestart("muffleWarning")
[17:29:41.889]                       }
[17:29:41.889]                       else if (inherits(cond, "condition")) {
[17:29:41.889]                         if (!is.null(pattern)) {
[17:29:41.889]                           computeRestarts <- base::computeRestarts
[17:29:41.889]                           grepl <- base::grepl
[17:29:41.889]                           restarts <- computeRestarts(cond)
[17:29:41.889]                           for (restart in restarts) {
[17:29:41.889]                             name <- restart$name
[17:29:41.889]                             if (is.null(name)) 
[17:29:41.889]                               next
[17:29:41.889]                             if (!grepl(pattern, name)) 
[17:29:41.889]                               next
[17:29:41.889]                             invokeRestart(restart)
[17:29:41.889]                             muffled <- TRUE
[17:29:41.889]                             break
[17:29:41.889]                           }
[17:29:41.889]                         }
[17:29:41.889]                       }
[17:29:41.889]                       invisible(muffled)
[17:29:41.889]                     }
[17:29:41.889]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.889]                   }
[17:29:41.889]                 }
[17:29:41.889]                 else {
[17:29:41.889]                   if (TRUE) {
[17:29:41.889]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.889]                     {
[17:29:41.889]                       inherits <- base::inherits
[17:29:41.889]                       invokeRestart <- base::invokeRestart
[17:29:41.889]                       is.null <- base::is.null
[17:29:41.889]                       muffled <- FALSE
[17:29:41.889]                       if (inherits(cond, "message")) {
[17:29:41.889]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.889]                         if (muffled) 
[17:29:41.889]                           invokeRestart("muffleMessage")
[17:29:41.889]                       }
[17:29:41.889]                       else if (inherits(cond, "warning")) {
[17:29:41.889]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.889]                         if (muffled) 
[17:29:41.889]                           invokeRestart("muffleWarning")
[17:29:41.889]                       }
[17:29:41.889]                       else if (inherits(cond, "condition")) {
[17:29:41.889]                         if (!is.null(pattern)) {
[17:29:41.889]                           computeRestarts <- base::computeRestarts
[17:29:41.889]                           grepl <- base::grepl
[17:29:41.889]                           restarts <- computeRestarts(cond)
[17:29:41.889]                           for (restart in restarts) {
[17:29:41.889]                             name <- restart$name
[17:29:41.889]                             if (is.null(name)) 
[17:29:41.889]                               next
[17:29:41.889]                             if (!grepl(pattern, name)) 
[17:29:41.889]                               next
[17:29:41.889]                             invokeRestart(restart)
[17:29:41.889]                             muffled <- TRUE
[17:29:41.889]                             break
[17:29:41.889]                           }
[17:29:41.889]                         }
[17:29:41.889]                       }
[17:29:41.889]                       invisible(muffled)
[17:29:41.889]                     }
[17:29:41.889]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.889]                   }
[17:29:41.889]                 }
[17:29:41.889]             }
[17:29:41.889]         }))
[17:29:41.889]     }, error = function(ex) {
[17:29:41.889]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.889]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.889]                 ...future.rng), started = ...future.startTime, 
[17:29:41.889]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.889]             version = "1.8"), class = "FutureResult")
[17:29:41.889]     }, finally = {
[17:29:41.889]         if (!identical(...future.workdir, getwd())) 
[17:29:41.889]             setwd(...future.workdir)
[17:29:41.889]         {
[17:29:41.889]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.889]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.889]             }
[17:29:41.889]             base::options(...future.oldOptions)
[17:29:41.889]             if (.Platform$OS.type == "windows") {
[17:29:41.889]                 old_names <- names(...future.oldEnvVars)
[17:29:41.889]                 envs <- base::Sys.getenv()
[17:29:41.889]                 names <- names(envs)
[17:29:41.889]                 common <- intersect(names, old_names)
[17:29:41.889]                 added <- setdiff(names, old_names)
[17:29:41.889]                 removed <- setdiff(old_names, names)
[17:29:41.889]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.889]                   envs[common]]
[17:29:41.889]                 NAMES <- toupper(changed)
[17:29:41.889]                 args <- list()
[17:29:41.889]                 for (kk in seq_along(NAMES)) {
[17:29:41.889]                   name <- changed[[kk]]
[17:29:41.889]                   NAME <- NAMES[[kk]]
[17:29:41.889]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.889]                     next
[17:29:41.889]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.889]                 }
[17:29:41.889]                 NAMES <- toupper(added)
[17:29:41.889]                 for (kk in seq_along(NAMES)) {
[17:29:41.889]                   name <- added[[kk]]
[17:29:41.889]                   NAME <- NAMES[[kk]]
[17:29:41.889]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.889]                     next
[17:29:41.889]                   args[[name]] <- ""
[17:29:41.889]                 }
[17:29:41.889]                 NAMES <- toupper(removed)
[17:29:41.889]                 for (kk in seq_along(NAMES)) {
[17:29:41.889]                   name <- removed[[kk]]
[17:29:41.889]                   NAME <- NAMES[[kk]]
[17:29:41.889]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.889]                     next
[17:29:41.889]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.889]                 }
[17:29:41.889]                 if (length(args) > 0) 
[17:29:41.889]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.889]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.889]             }
[17:29:41.889]             else {
[17:29:41.889]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.889]             }
[17:29:41.889]             {
[17:29:41.889]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.889]                   0L) {
[17:29:41.889]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.889]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.889]                   base::options(opts)
[17:29:41.889]                 }
[17:29:41.889]                 {
[17:29:41.889]                   {
[17:29:41.889]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:41.889]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:41.889]                     -1344458670L), envir = base::globalenv(), 
[17:29:41.889]                       inherits = FALSE)
[17:29:41.889]                     NULL
[17:29:41.889]                   }
[17:29:41.889]                   options(future.plan = NULL)
[17:29:41.889]                   if (is.na(NA_character_)) 
[17:29:41.889]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.889]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.889]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.889]                     .init = FALSE)
[17:29:41.889]                 }
[17:29:41.889]             }
[17:29:41.889]         }
[17:29:41.889]     })
[17:29:41.889]     if (TRUE) {
[17:29:41.889]         base::sink(type = "output", split = FALSE)
[17:29:41.889]         if (TRUE) {
[17:29:41.889]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.889]         }
[17:29:41.889]         else {
[17:29:41.889]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.889]         }
[17:29:41.889]         base::close(...future.stdout)
[17:29:41.889]         ...future.stdout <- NULL
[17:29:41.889]     }
[17:29:41.889]     ...future.result$conditions <- ...future.conditions
[17:29:41.889]     ...future.result$finished <- base::Sys.time()
[17:29:41.889]     ...future.result
[17:29:41.889] }
[17:29:41.896] assign_globals() ...
[17:29:41.896] List of 1
[17:29:41.896]  $ x: int [1:4] 0 1 2 3
[17:29:41.896]  - attr(*, "where")=List of 1
[17:29:41.896]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.896]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.896]  - attr(*, "resolved")= logi FALSE
[17:29:41.896]  - attr(*, "total_size")= int 133
[17:29:41.896]  - attr(*, "already-done")= logi TRUE
[17:29:41.905] - copied 'x' to environment
[17:29:41.905] assign_globals() ... done
[17:29:41.906] plan(): Setting new future strategy stack:
[17:29:41.906] List of future strategies:
[17:29:41.906] 1. sequential:
[17:29:41.906]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.906]    - tweaked: FALSE
[17:29:41.906]    - call: NULL
[17:29:41.907] plan(): nbrOfWorkers() = 1
[17:29:41.909] plan(): Setting new future strategy stack:
[17:29:41.909] List of future strategies:
[17:29:41.909] 1. sequential:
[17:29:41.909]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.909]    - tweaked: FALSE
[17:29:41.909]    - call: plan(strategy)
[17:29:41.911] plan(): nbrOfWorkers() = 1
[17:29:41.911] SequentialFuture started (and completed)
[17:29:41.911] - Launch lazy future ... done
[17:29:41.912] run() for 'SequentialFuture' ... done
[17:29:41.913] getGlobalsAndPackages() ...
[17:29:41.913] Searching for globals...
[17:29:41.915] - globals found: [3] '{', 'sample', 'x'
[17:29:41.916] Searching for globals ... DONE
[17:29:41.916] Resolving globals: FALSE
[17:29:41.917] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.917] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.918] - globals: [1] 'x'
[17:29:41.918] 
[17:29:41.918] getGlobalsAndPackages() ... DONE
[17:29:41.919] run() for 'Future' ...
[17:29:41.919] - state: 'created'
[17:29:41.920] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.920] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.921] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.921]   - Field: 'label'
[17:29:41.921]   - Field: 'local'
[17:29:41.922]   - Field: 'owner'
[17:29:41.922]   - Field: 'envir'
[17:29:41.922]   - Field: 'packages'
[17:29:41.923]   - Field: 'gc'
[17:29:41.923]   - Field: 'conditions'
[17:29:41.923]   - Field: 'expr'
[17:29:41.924]   - Field: 'uuid'
[17:29:41.924]   - Field: 'seed'
[17:29:41.924]   - Field: 'version'
[17:29:41.925]   - Field: 'result'
[17:29:41.925]   - Field: 'asynchronous'
[17:29:41.925]   - Field: 'calls'
[17:29:41.926]   - Field: 'globals'
[17:29:41.926]   - Field: 'stdout'
[17:29:41.926]   - Field: 'earlySignal'
[17:29:41.927]   - Field: 'lazy'
[17:29:41.927]   - Field: 'state'
[17:29:41.927] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.928] - Launch lazy future ...
[17:29:41.928] Packages needed by the future expression (n = 0): <none>
[17:29:41.928] Packages needed by future strategies (n = 0): <none>
[17:29:41.929] {
[17:29:41.929]     {
[17:29:41.929]         {
[17:29:41.929]             ...future.startTime <- base::Sys.time()
[17:29:41.929]             {
[17:29:41.929]                 {
[17:29:41.929]                   {
[17:29:41.929]                     {
[17:29:41.929]                       base::local({
[17:29:41.929]                         has_future <- base::requireNamespace("future", 
[17:29:41.929]                           quietly = TRUE)
[17:29:41.929]                         if (has_future) {
[17:29:41.929]                           ns <- base::getNamespace("future")
[17:29:41.929]                           version <- ns[[".package"]][["version"]]
[17:29:41.929]                           if (is.null(version)) 
[17:29:41.929]                             version <- utils::packageVersion("future")
[17:29:41.929]                         }
[17:29:41.929]                         else {
[17:29:41.929]                           version <- NULL
[17:29:41.929]                         }
[17:29:41.929]                         if (!has_future || version < "1.8.0") {
[17:29:41.929]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.929]                             "", base::R.version$version.string), 
[17:29:41.929]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:41.929]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.929]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.929]                               "release", "version")], collapse = " "), 
[17:29:41.929]                             hostname = base::Sys.info()[["nodename"]])
[17:29:41.929]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.929]                             info)
[17:29:41.929]                           info <- base::paste(info, collapse = "; ")
[17:29:41.929]                           if (!has_future) {
[17:29:41.929]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.929]                               info)
[17:29:41.929]                           }
[17:29:41.929]                           else {
[17:29:41.929]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.929]                               info, version)
[17:29:41.929]                           }
[17:29:41.929]                           base::stop(msg)
[17:29:41.929]                         }
[17:29:41.929]                       })
[17:29:41.929]                     }
[17:29:41.929]                     ...future.strategy.old <- future::plan("list")
[17:29:41.929]                     options(future.plan = NULL)
[17:29:41.929]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.929]                     future::plan("default", .cleanup = FALSE, 
[17:29:41.929]                       .init = FALSE)
[17:29:41.929]                   }
[17:29:41.929]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[17:29:41.929]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[17:29:41.929]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[17:29:41.929]                 }
[17:29:41.929]                 ...future.workdir <- getwd()
[17:29:41.929]             }
[17:29:41.929]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.929]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.929]         }
[17:29:41.929]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.929]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.929]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.929]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.929]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.929]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.929]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.929]             base::names(...future.oldOptions))
[17:29:41.929]     }
[17:29:41.929]     if (FALSE) {
[17:29:41.929]     }
[17:29:41.929]     else {
[17:29:41.929]         if (TRUE) {
[17:29:41.929]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.929]                 open = "w")
[17:29:41.929]         }
[17:29:41.929]         else {
[17:29:41.929]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.929]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.929]         }
[17:29:41.929]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.929]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.929]             base::sink(type = "output", split = FALSE)
[17:29:41.929]             base::close(...future.stdout)
[17:29:41.929]         }, add = TRUE)
[17:29:41.929]     }
[17:29:41.929]     ...future.frame <- base::sys.nframe()
[17:29:41.929]     ...future.conditions <- base::list()
[17:29:41.929]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.929]     if (FALSE) {
[17:29:41.929]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.929]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.929]     }
[17:29:41.929]     ...future.result <- base::tryCatch({
[17:29:41.929]         base::withCallingHandlers({
[17:29:41.929]             ...future.value <- base::withVisible(base::local({
[17:29:41.929]                 sample(x, size = 1L)
[17:29:41.929]             }))
[17:29:41.929]             future::FutureResult(value = ...future.value$value, 
[17:29:41.929]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.929]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.929]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.929]                     ...future.globalenv.names))
[17:29:41.929]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.929]         }, condition = base::local({
[17:29:41.929]             c <- base::c
[17:29:41.929]             inherits <- base::inherits
[17:29:41.929]             invokeRestart <- base::invokeRestart
[17:29:41.929]             length <- base::length
[17:29:41.929]             list <- base::list
[17:29:41.929]             seq.int <- base::seq.int
[17:29:41.929]             signalCondition <- base::signalCondition
[17:29:41.929]             sys.calls <- base::sys.calls
[17:29:41.929]             `[[` <- base::`[[`
[17:29:41.929]             `+` <- base::`+`
[17:29:41.929]             `<<-` <- base::`<<-`
[17:29:41.929]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.929]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.929]                   3L)]
[17:29:41.929]             }
[17:29:41.929]             function(cond) {
[17:29:41.929]                 is_error <- inherits(cond, "error")
[17:29:41.929]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.929]                   NULL)
[17:29:41.929]                 if (is_error) {
[17:29:41.929]                   sessionInformation <- function() {
[17:29:41.929]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.929]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.929]                       search = base::search(), system = base::Sys.info())
[17:29:41.929]                   }
[17:29:41.929]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.929]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.929]                     cond$call), session = sessionInformation(), 
[17:29:41.929]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.929]                   signalCondition(cond)
[17:29:41.929]                 }
[17:29:41.929]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.929]                 "immediateCondition"))) {
[17:29:41.929]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.929]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.929]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.929]                   if (TRUE && !signal) {
[17:29:41.929]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.929]                     {
[17:29:41.929]                       inherits <- base::inherits
[17:29:41.929]                       invokeRestart <- base::invokeRestart
[17:29:41.929]                       is.null <- base::is.null
[17:29:41.929]                       muffled <- FALSE
[17:29:41.929]                       if (inherits(cond, "message")) {
[17:29:41.929]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.929]                         if (muffled) 
[17:29:41.929]                           invokeRestart("muffleMessage")
[17:29:41.929]                       }
[17:29:41.929]                       else if (inherits(cond, "warning")) {
[17:29:41.929]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.929]                         if (muffled) 
[17:29:41.929]                           invokeRestart("muffleWarning")
[17:29:41.929]                       }
[17:29:41.929]                       else if (inherits(cond, "condition")) {
[17:29:41.929]                         if (!is.null(pattern)) {
[17:29:41.929]                           computeRestarts <- base::computeRestarts
[17:29:41.929]                           grepl <- base::grepl
[17:29:41.929]                           restarts <- computeRestarts(cond)
[17:29:41.929]                           for (restart in restarts) {
[17:29:41.929]                             name <- restart$name
[17:29:41.929]                             if (is.null(name)) 
[17:29:41.929]                               next
[17:29:41.929]                             if (!grepl(pattern, name)) 
[17:29:41.929]                               next
[17:29:41.929]                             invokeRestart(restart)
[17:29:41.929]                             muffled <- TRUE
[17:29:41.929]                             break
[17:29:41.929]                           }
[17:29:41.929]                         }
[17:29:41.929]                       }
[17:29:41.929]                       invisible(muffled)
[17:29:41.929]                     }
[17:29:41.929]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.929]                   }
[17:29:41.929]                 }
[17:29:41.929]                 else {
[17:29:41.929]                   if (TRUE) {
[17:29:41.929]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.929]                     {
[17:29:41.929]                       inherits <- base::inherits
[17:29:41.929]                       invokeRestart <- base::invokeRestart
[17:29:41.929]                       is.null <- base::is.null
[17:29:41.929]                       muffled <- FALSE
[17:29:41.929]                       if (inherits(cond, "message")) {
[17:29:41.929]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.929]                         if (muffled) 
[17:29:41.929]                           invokeRestart("muffleMessage")
[17:29:41.929]                       }
[17:29:41.929]                       else if (inherits(cond, "warning")) {
[17:29:41.929]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.929]                         if (muffled) 
[17:29:41.929]                           invokeRestart("muffleWarning")
[17:29:41.929]                       }
[17:29:41.929]                       else if (inherits(cond, "condition")) {
[17:29:41.929]                         if (!is.null(pattern)) {
[17:29:41.929]                           computeRestarts <- base::computeRestarts
[17:29:41.929]                           grepl <- base::grepl
[17:29:41.929]                           restarts <- computeRestarts(cond)
[17:29:41.929]                           for (restart in restarts) {
[17:29:41.929]                             name <- restart$name
[17:29:41.929]                             if (is.null(name)) 
[17:29:41.929]                               next
[17:29:41.929]                             if (!grepl(pattern, name)) 
[17:29:41.929]                               next
[17:29:41.929]                             invokeRestart(restart)
[17:29:41.929]                             muffled <- TRUE
[17:29:41.929]                             break
[17:29:41.929]                           }
[17:29:41.929]                         }
[17:29:41.929]                       }
[17:29:41.929]                       invisible(muffled)
[17:29:41.929]                     }
[17:29:41.929]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.929]                   }
[17:29:41.929]                 }
[17:29:41.929]             }
[17:29:41.929]         }))
[17:29:41.929]     }, error = function(ex) {
[17:29:41.929]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.929]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.929]                 ...future.rng), started = ...future.startTime, 
[17:29:41.929]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.929]             version = "1.8"), class = "FutureResult")
[17:29:41.929]     }, finally = {
[17:29:41.929]         if (!identical(...future.workdir, getwd())) 
[17:29:41.929]             setwd(...future.workdir)
[17:29:41.929]         {
[17:29:41.929]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.929]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.929]             }
[17:29:41.929]             base::options(...future.oldOptions)
[17:29:41.929]             if (.Platform$OS.type == "windows") {
[17:29:41.929]                 old_names <- names(...future.oldEnvVars)
[17:29:41.929]                 envs <- base::Sys.getenv()
[17:29:41.929]                 names <- names(envs)
[17:29:41.929]                 common <- intersect(names, old_names)
[17:29:41.929]                 added <- setdiff(names, old_names)
[17:29:41.929]                 removed <- setdiff(old_names, names)
[17:29:41.929]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.929]                   envs[common]]
[17:29:41.929]                 NAMES <- toupper(changed)
[17:29:41.929]                 args <- list()
[17:29:41.929]                 for (kk in seq_along(NAMES)) {
[17:29:41.929]                   name <- changed[[kk]]
[17:29:41.929]                   NAME <- NAMES[[kk]]
[17:29:41.929]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.929]                     next
[17:29:41.929]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.929]                 }
[17:29:41.929]                 NAMES <- toupper(added)
[17:29:41.929]                 for (kk in seq_along(NAMES)) {
[17:29:41.929]                   name <- added[[kk]]
[17:29:41.929]                   NAME <- NAMES[[kk]]
[17:29:41.929]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.929]                     next
[17:29:41.929]                   args[[name]] <- ""
[17:29:41.929]                 }
[17:29:41.929]                 NAMES <- toupper(removed)
[17:29:41.929]                 for (kk in seq_along(NAMES)) {
[17:29:41.929]                   name <- removed[[kk]]
[17:29:41.929]                   NAME <- NAMES[[kk]]
[17:29:41.929]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.929]                     next
[17:29:41.929]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.929]                 }
[17:29:41.929]                 if (length(args) > 0) 
[17:29:41.929]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.929]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.929]             }
[17:29:41.929]             else {
[17:29:41.929]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.929]             }
[17:29:41.929]             {
[17:29:41.929]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.929]                   0L) {
[17:29:41.929]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.929]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.929]                   base::options(opts)
[17:29:41.929]                 }
[17:29:41.929]                 {
[17:29:41.929]                   {
[17:29:41.929]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:41.929]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:41.929]                     -1344458670L), envir = base::globalenv(), 
[17:29:41.929]                       inherits = FALSE)
[17:29:41.929]                     NULL
[17:29:41.929]                   }
[17:29:41.929]                   options(future.plan = NULL)
[17:29:41.929]                   if (is.na(NA_character_)) 
[17:29:41.929]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.929]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.929]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.929]                     .init = FALSE)
[17:29:41.929]                 }
[17:29:41.929]             }
[17:29:41.929]         }
[17:29:41.929]     })
[17:29:41.929]     if (TRUE) {
[17:29:41.929]         base::sink(type = "output", split = FALSE)
[17:29:41.929]         if (TRUE) {
[17:29:41.929]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.929]         }
[17:29:41.929]         else {
[17:29:41.929]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.929]         }
[17:29:41.929]         base::close(...future.stdout)
[17:29:41.929]         ...future.stdout <- NULL
[17:29:41.929]     }
[17:29:41.929]     ...future.result$conditions <- ...future.conditions
[17:29:41.929]     ...future.result$finished <- base::Sys.time()
[17:29:41.929]     ...future.result
[17:29:41.929] }
[17:29:41.936] assign_globals() ...
[17:29:41.936] List of 1
[17:29:41.936]  $ x: int [1:4] 0 1 2 3
[17:29:41.936]  - attr(*, "where")=List of 1
[17:29:41.936]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.936]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.936]  - attr(*, "resolved")= logi FALSE
[17:29:41.936]  - attr(*, "total_size")= int 133
[17:29:41.936]  - attr(*, "already-done")= logi TRUE
[17:29:41.941] - copied 'x' to environment
[17:29:41.942] assign_globals() ... done
[17:29:41.942] plan(): Setting new future strategy stack:
[17:29:41.943] List of future strategies:
[17:29:41.943] 1. sequential:
[17:29:41.943]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.943]    - tweaked: FALSE
[17:29:41.943]    - call: NULL
[17:29:41.944] plan(): nbrOfWorkers() = 1
[17:29:41.946] plan(): Setting new future strategy stack:
[17:29:41.946] List of future strategies:
[17:29:41.946] 1. sequential:
[17:29:41.946]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.946]    - tweaked: FALSE
[17:29:41.946]    - call: plan(strategy)
[17:29:41.947] plan(): nbrOfWorkers() = 1
[17:29:41.948] SequentialFuture started (and completed)
[17:29:41.948] - Launch lazy future ... done
[17:29:41.948] run() for 'SequentialFuture' ... done
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[17:29:41.950] getGlobalsAndPackages() ...
[17:29:41.950] Searching for globals...
[17:29:41.957] - globals found: [3] '{', 'sample', 'x'
[17:29:41.958] Searching for globals ... DONE
[17:29:41.958] Resolving globals: FALSE
[17:29:41.959] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.960] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.960] - globals: [1] 'x'
[17:29:41.961] 
[17:29:41.961] getGlobalsAndPackages() ... DONE
[17:29:41.962] run() for 'Future' ...
[17:29:41.962] - state: 'created'
[17:29:41.962] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.963] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.963] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.964]   - Field: 'label'
[17:29:41.964]   - Field: 'local'
[17:29:41.964]   - Field: 'owner'
[17:29:41.965]   - Field: 'envir'
[17:29:41.965]   - Field: 'packages'
[17:29:41.965]   - Field: 'gc'
[17:29:41.966]   - Field: 'conditions'
[17:29:41.966]   - Field: 'expr'
[17:29:41.966]   - Field: 'uuid'
[17:29:41.967]   - Field: 'seed'
[17:29:41.967]   - Field: 'version'
[17:29:41.967]   - Field: 'result'
[17:29:41.968]   - Field: 'asynchronous'
[17:29:41.968]   - Field: 'calls'
[17:29:41.968]   - Field: 'globals'
[17:29:41.969]   - Field: 'stdout'
[17:29:41.969]   - Field: 'earlySignal'
[17:29:41.969]   - Field: 'lazy'
[17:29:41.970]   - Field: 'state'
[17:29:41.970] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.970] - Launch lazy future ...
[17:29:41.971] Packages needed by the future expression (n = 0): <none>
[17:29:41.971] Packages needed by future strategies (n = 0): <none>
[17:29:41.972] {
[17:29:41.972]     {
[17:29:41.972]         {
[17:29:41.972]             ...future.startTime <- base::Sys.time()
[17:29:41.972]             {
[17:29:41.972]                 {
[17:29:41.972]                   {
[17:29:41.972]                     {
[17:29:41.972]                       base::local({
[17:29:41.972]                         has_future <- base::requireNamespace("future", 
[17:29:41.972]                           quietly = TRUE)
[17:29:41.972]                         if (has_future) {
[17:29:41.972]                           ns <- base::getNamespace("future")
[17:29:41.972]                           version <- ns[[".package"]][["version"]]
[17:29:41.972]                           if (is.null(version)) 
[17:29:41.972]                             version <- utils::packageVersion("future")
[17:29:41.972]                         }
[17:29:41.972]                         else {
[17:29:41.972]                           version <- NULL
[17:29:41.972]                         }
[17:29:41.972]                         if (!has_future || version < "1.8.0") {
[17:29:41.972]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.972]                             "", base::R.version$version.string), 
[17:29:41.972]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:41.972]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.972]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.972]                               "release", "version")], collapse = " "), 
[17:29:41.972]                             hostname = base::Sys.info()[["nodename"]])
[17:29:41.972]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.972]                             info)
[17:29:41.972]                           info <- base::paste(info, collapse = "; ")
[17:29:41.972]                           if (!has_future) {
[17:29:41.972]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.972]                               info)
[17:29:41.972]                           }
[17:29:41.972]                           else {
[17:29:41.972]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.972]                               info, version)
[17:29:41.972]                           }
[17:29:41.972]                           base::stop(msg)
[17:29:41.972]                         }
[17:29:41.972]                       })
[17:29:41.972]                     }
[17:29:41.972]                     ...future.strategy.old <- future::plan("list")
[17:29:41.972]                     options(future.plan = NULL)
[17:29:41.972]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.972]                     future::plan("default", .cleanup = FALSE, 
[17:29:41.972]                       .init = FALSE)
[17:29:41.972]                   }
[17:29:41.972]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[17:29:41.972]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[17:29:41.972]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[17:29:41.972]                 }
[17:29:41.972]                 ...future.workdir <- getwd()
[17:29:41.972]             }
[17:29:41.972]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.972]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.972]         }
[17:29:41.972]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.972]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.972]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.972]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.972]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.972]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.972]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.972]             base::names(...future.oldOptions))
[17:29:41.972]     }
[17:29:41.972]     if (FALSE) {
[17:29:41.972]     }
[17:29:41.972]     else {
[17:29:41.972]         if (TRUE) {
[17:29:41.972]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.972]                 open = "w")
[17:29:41.972]         }
[17:29:41.972]         else {
[17:29:41.972]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.972]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.972]         }
[17:29:41.972]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.972]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.972]             base::sink(type = "output", split = FALSE)
[17:29:41.972]             base::close(...future.stdout)
[17:29:41.972]         }, add = TRUE)
[17:29:41.972]     }
[17:29:41.972]     ...future.frame <- base::sys.nframe()
[17:29:41.972]     ...future.conditions <- base::list()
[17:29:41.972]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.972]     if (FALSE) {
[17:29:41.972]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.972]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.972]     }
[17:29:41.972]     ...future.result <- base::tryCatch({
[17:29:41.972]         base::withCallingHandlers({
[17:29:41.972]             ...future.value <- base::withVisible(base::local({
[17:29:41.972]                 sample(x, size = 1L)
[17:29:41.972]             }))
[17:29:41.972]             future::FutureResult(value = ...future.value$value, 
[17:29:41.972]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.972]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.972]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.972]                     ...future.globalenv.names))
[17:29:41.972]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.972]         }, condition = base::local({
[17:29:41.972]             c <- base::c
[17:29:41.972]             inherits <- base::inherits
[17:29:41.972]             invokeRestart <- base::invokeRestart
[17:29:41.972]             length <- base::length
[17:29:41.972]             list <- base::list
[17:29:41.972]             seq.int <- base::seq.int
[17:29:41.972]             signalCondition <- base::signalCondition
[17:29:41.972]             sys.calls <- base::sys.calls
[17:29:41.972]             `[[` <- base::`[[`
[17:29:41.972]             `+` <- base::`+`
[17:29:41.972]             `<<-` <- base::`<<-`
[17:29:41.972]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.972]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.972]                   3L)]
[17:29:41.972]             }
[17:29:41.972]             function(cond) {
[17:29:41.972]                 is_error <- inherits(cond, "error")
[17:29:41.972]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.972]                   NULL)
[17:29:41.972]                 if (is_error) {
[17:29:41.972]                   sessionInformation <- function() {
[17:29:41.972]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.972]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.972]                       search = base::search(), system = base::Sys.info())
[17:29:41.972]                   }
[17:29:41.972]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.972]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.972]                     cond$call), session = sessionInformation(), 
[17:29:41.972]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.972]                   signalCondition(cond)
[17:29:41.972]                 }
[17:29:41.972]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.972]                 "immediateCondition"))) {
[17:29:41.972]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.972]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.972]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.972]                   if (TRUE && !signal) {
[17:29:41.972]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.972]                     {
[17:29:41.972]                       inherits <- base::inherits
[17:29:41.972]                       invokeRestart <- base::invokeRestart
[17:29:41.972]                       is.null <- base::is.null
[17:29:41.972]                       muffled <- FALSE
[17:29:41.972]                       if (inherits(cond, "message")) {
[17:29:41.972]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.972]                         if (muffled) 
[17:29:41.972]                           invokeRestart("muffleMessage")
[17:29:41.972]                       }
[17:29:41.972]                       else if (inherits(cond, "warning")) {
[17:29:41.972]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.972]                         if (muffled) 
[17:29:41.972]                           invokeRestart("muffleWarning")
[17:29:41.972]                       }
[17:29:41.972]                       else if (inherits(cond, "condition")) {
[17:29:41.972]                         if (!is.null(pattern)) {
[17:29:41.972]                           computeRestarts <- base::computeRestarts
[17:29:41.972]                           grepl <- base::grepl
[17:29:41.972]                           restarts <- computeRestarts(cond)
[17:29:41.972]                           for (restart in restarts) {
[17:29:41.972]                             name <- restart$name
[17:29:41.972]                             if (is.null(name)) 
[17:29:41.972]                               next
[17:29:41.972]                             if (!grepl(pattern, name)) 
[17:29:41.972]                               next
[17:29:41.972]                             invokeRestart(restart)
[17:29:41.972]                             muffled <- TRUE
[17:29:41.972]                             break
[17:29:41.972]                           }
[17:29:41.972]                         }
[17:29:41.972]                       }
[17:29:41.972]                       invisible(muffled)
[17:29:41.972]                     }
[17:29:41.972]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.972]                   }
[17:29:41.972]                 }
[17:29:41.972]                 else {
[17:29:41.972]                   if (TRUE) {
[17:29:41.972]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.972]                     {
[17:29:41.972]                       inherits <- base::inherits
[17:29:41.972]                       invokeRestart <- base::invokeRestart
[17:29:41.972]                       is.null <- base::is.null
[17:29:41.972]                       muffled <- FALSE
[17:29:41.972]                       if (inherits(cond, "message")) {
[17:29:41.972]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.972]                         if (muffled) 
[17:29:41.972]                           invokeRestart("muffleMessage")
[17:29:41.972]                       }
[17:29:41.972]                       else if (inherits(cond, "warning")) {
[17:29:41.972]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.972]                         if (muffled) 
[17:29:41.972]                           invokeRestart("muffleWarning")
[17:29:41.972]                       }
[17:29:41.972]                       else if (inherits(cond, "condition")) {
[17:29:41.972]                         if (!is.null(pattern)) {
[17:29:41.972]                           computeRestarts <- base::computeRestarts
[17:29:41.972]                           grepl <- base::grepl
[17:29:41.972]                           restarts <- computeRestarts(cond)
[17:29:41.972]                           for (restart in restarts) {
[17:29:41.972]                             name <- restart$name
[17:29:41.972]                             if (is.null(name)) 
[17:29:41.972]                               next
[17:29:41.972]                             if (!grepl(pattern, name)) 
[17:29:41.972]                               next
[17:29:41.972]                             invokeRestart(restart)
[17:29:41.972]                             muffled <- TRUE
[17:29:41.972]                             break
[17:29:41.972]                           }
[17:29:41.972]                         }
[17:29:41.972]                       }
[17:29:41.972]                       invisible(muffled)
[17:29:41.972]                     }
[17:29:41.972]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.972]                   }
[17:29:41.972]                 }
[17:29:41.972]             }
[17:29:41.972]         }))
[17:29:41.972]     }, error = function(ex) {
[17:29:41.972]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.972]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.972]                 ...future.rng), started = ...future.startTime, 
[17:29:41.972]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.972]             version = "1.8"), class = "FutureResult")
[17:29:41.972]     }, finally = {
[17:29:41.972]         if (!identical(...future.workdir, getwd())) 
[17:29:41.972]             setwd(...future.workdir)
[17:29:41.972]         {
[17:29:41.972]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.972]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.972]             }
[17:29:41.972]             base::options(...future.oldOptions)
[17:29:41.972]             if (.Platform$OS.type == "windows") {
[17:29:41.972]                 old_names <- names(...future.oldEnvVars)
[17:29:41.972]                 envs <- base::Sys.getenv()
[17:29:41.972]                 names <- names(envs)
[17:29:41.972]                 common <- intersect(names, old_names)
[17:29:41.972]                 added <- setdiff(names, old_names)
[17:29:41.972]                 removed <- setdiff(old_names, names)
[17:29:41.972]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.972]                   envs[common]]
[17:29:41.972]                 NAMES <- toupper(changed)
[17:29:41.972]                 args <- list()
[17:29:41.972]                 for (kk in seq_along(NAMES)) {
[17:29:41.972]                   name <- changed[[kk]]
[17:29:41.972]                   NAME <- NAMES[[kk]]
[17:29:41.972]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.972]                     next
[17:29:41.972]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.972]                 }
[17:29:41.972]                 NAMES <- toupper(added)
[17:29:41.972]                 for (kk in seq_along(NAMES)) {
[17:29:41.972]                   name <- added[[kk]]
[17:29:41.972]                   NAME <- NAMES[[kk]]
[17:29:41.972]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.972]                     next
[17:29:41.972]                   args[[name]] <- ""
[17:29:41.972]                 }
[17:29:41.972]                 NAMES <- toupper(removed)
[17:29:41.972]                 for (kk in seq_along(NAMES)) {
[17:29:41.972]                   name <- removed[[kk]]
[17:29:41.972]                   NAME <- NAMES[[kk]]
[17:29:41.972]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.972]                     next
[17:29:41.972]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.972]                 }
[17:29:41.972]                 if (length(args) > 0) 
[17:29:41.972]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.972]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.972]             }
[17:29:41.972]             else {
[17:29:41.972]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.972]             }
[17:29:41.972]             {
[17:29:41.972]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.972]                   0L) {
[17:29:41.972]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.972]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.972]                   base::options(opts)
[17:29:41.972]                 }
[17:29:41.972]                 {
[17:29:41.972]                   {
[17:29:41.972]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:41.972]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:41.972]                     -1344458670L), envir = base::globalenv(), 
[17:29:41.972]                       inherits = FALSE)
[17:29:41.972]                     NULL
[17:29:41.972]                   }
[17:29:41.972]                   options(future.plan = NULL)
[17:29:41.972]                   if (is.na(NA_character_)) 
[17:29:41.972]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.972]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.972]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.972]                     .init = FALSE)
[17:29:41.972]                 }
[17:29:41.972]             }
[17:29:41.972]         }
[17:29:41.972]     })
[17:29:41.972]     if (TRUE) {
[17:29:41.972]         base::sink(type = "output", split = FALSE)
[17:29:41.972]         if (TRUE) {
[17:29:41.972]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.972]         }
[17:29:41.972]         else {
[17:29:41.972]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.972]         }
[17:29:41.972]         base::close(...future.stdout)
[17:29:41.972]         ...future.stdout <- NULL
[17:29:41.972]     }
[17:29:41.972]     ...future.result$conditions <- ...future.conditions
[17:29:41.972]     ...future.result$finished <- base::Sys.time()
[17:29:41.972]     ...future.result
[17:29:41.972] }
[17:29:41.978] assign_globals() ...
[17:29:41.978] List of 1
[17:29:41.978]  $ x: int [1:4] 0 1 2 3
[17:29:41.978]  - attr(*, "where")=List of 1
[17:29:41.978]   ..$ x:<environment: R_EmptyEnv> 
[17:29:41.978]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:41.978]  - attr(*, "resolved")= logi FALSE
[17:29:41.978]  - attr(*, "total_size")= int 133
[17:29:41.978]  - attr(*, "already-done")= logi TRUE
[17:29:41.982] - copied 'x' to environment
[17:29:41.982] assign_globals() ... done
[17:29:41.982] plan(): Setting new future strategy stack:
[17:29:41.982] List of future strategies:
[17:29:41.982] 1. sequential:
[17:29:41.982]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.982]    - tweaked: FALSE
[17:29:41.982]    - call: NULL
[17:29:41.983] plan(): nbrOfWorkers() = 1
[17:29:41.984] plan(): Setting new future strategy stack:
[17:29:41.984] List of future strategies:
[17:29:41.984] 1. sequential:
[17:29:41.984]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:41.984]    - tweaked: FALSE
[17:29:41.984]    - call: plan(strategy)
[17:29:41.985] plan(): nbrOfWorkers() = 1
[17:29:41.985] SequentialFuture started (and completed)
[17:29:41.986] - Launch lazy future ... done
[17:29:41.986] run() for 'SequentialFuture' ... done
[17:29:41.986] getGlobalsAndPackages() ...
[17:29:41.987] Searching for globals...
[17:29:41.988] - globals found: [3] '{', 'sample', 'x'
[17:29:41.988] Searching for globals ... DONE
[17:29:41.988] Resolving globals: FALSE
[17:29:41.989] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:41.990] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:41.990] - globals: [1] 'x'
[17:29:41.990] 
[17:29:41.990] getGlobalsAndPackages() ... DONE
[17:29:41.991] run() for 'Future' ...
[17:29:41.991] - state: 'created'
[17:29:41.991] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:41.992] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:41.992] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:41.992]   - Field: 'label'
[17:29:41.992]   - Field: 'local'
[17:29:41.993]   - Field: 'owner'
[17:29:41.993]   - Field: 'envir'
[17:29:41.993]   - Field: 'packages'
[17:29:41.993]   - Field: 'gc'
[17:29:41.994]   - Field: 'conditions'
[17:29:41.994]   - Field: 'expr'
[17:29:41.994]   - Field: 'uuid'
[17:29:41.994]   - Field: 'seed'
[17:29:41.994]   - Field: 'version'
[17:29:41.994]   - Field: 'result'
[17:29:41.995]   - Field: 'asynchronous'
[17:29:41.995]   - Field: 'calls'
[17:29:41.995]   - Field: 'globals'
[17:29:41.995]   - Field: 'stdout'
[17:29:41.995]   - Field: 'earlySignal'
[17:29:41.995]   - Field: 'lazy'
[17:29:41.996]   - Field: 'state'
[17:29:41.996] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:41.996] - Launch lazy future ...
[17:29:41.996] Packages needed by the future expression (n = 0): <none>
[17:29:41.996] Packages needed by future strategies (n = 0): <none>
[17:29:41.997] {
[17:29:41.997]     {
[17:29:41.997]         {
[17:29:41.997]             ...future.startTime <- base::Sys.time()
[17:29:41.997]             {
[17:29:41.997]                 {
[17:29:41.997]                   {
[17:29:41.997]                     {
[17:29:41.997]                       base::local({
[17:29:41.997]                         has_future <- base::requireNamespace("future", 
[17:29:41.997]                           quietly = TRUE)
[17:29:41.997]                         if (has_future) {
[17:29:41.997]                           ns <- base::getNamespace("future")
[17:29:41.997]                           version <- ns[[".package"]][["version"]]
[17:29:41.997]                           if (is.null(version)) 
[17:29:41.997]                             version <- utils::packageVersion("future")
[17:29:41.997]                         }
[17:29:41.997]                         else {
[17:29:41.997]                           version <- NULL
[17:29:41.997]                         }
[17:29:41.997]                         if (!has_future || version < "1.8.0") {
[17:29:41.997]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:41.997]                             "", base::R.version$version.string), 
[17:29:41.997]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:41.997]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:41.997]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:41.997]                               "release", "version")], collapse = " "), 
[17:29:41.997]                             hostname = base::Sys.info()[["nodename"]])
[17:29:41.997]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:41.997]                             info)
[17:29:41.997]                           info <- base::paste(info, collapse = "; ")
[17:29:41.997]                           if (!has_future) {
[17:29:41.997]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:41.997]                               info)
[17:29:41.997]                           }
[17:29:41.997]                           else {
[17:29:41.997]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:41.997]                               info, version)
[17:29:41.997]                           }
[17:29:41.997]                           base::stop(msg)
[17:29:41.997]                         }
[17:29:41.997]                       })
[17:29:41.997]                     }
[17:29:41.997]                     ...future.strategy.old <- future::plan("list")
[17:29:41.997]                     options(future.plan = NULL)
[17:29:41.997]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.997]                     future::plan("default", .cleanup = FALSE, 
[17:29:41.997]                       .init = FALSE)
[17:29:41.997]                   }
[17:29:41.997]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[17:29:41.997]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[17:29:41.997]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[17:29:41.997]                 }
[17:29:41.997]                 ...future.workdir <- getwd()
[17:29:41.997]             }
[17:29:41.997]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:41.997]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:41.997]         }
[17:29:41.997]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:41.997]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:41.997]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:41.997]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:41.997]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:41.997]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:41.997]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:41.997]             base::names(...future.oldOptions))
[17:29:41.997]     }
[17:29:41.997]     if (FALSE) {
[17:29:41.997]     }
[17:29:41.997]     else {
[17:29:41.997]         if (TRUE) {
[17:29:41.997]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:41.997]                 open = "w")
[17:29:41.997]         }
[17:29:41.997]         else {
[17:29:41.997]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:41.997]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:41.997]         }
[17:29:41.997]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:41.997]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:41.997]             base::sink(type = "output", split = FALSE)
[17:29:41.997]             base::close(...future.stdout)
[17:29:41.997]         }, add = TRUE)
[17:29:41.997]     }
[17:29:41.997]     ...future.frame <- base::sys.nframe()
[17:29:41.997]     ...future.conditions <- base::list()
[17:29:41.997]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:41.997]     if (FALSE) {
[17:29:41.997]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:41.997]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:41.997]     }
[17:29:41.997]     ...future.result <- base::tryCatch({
[17:29:41.997]         base::withCallingHandlers({
[17:29:41.997]             ...future.value <- base::withVisible(base::local({
[17:29:41.997]                 sample(x, size = 1L)
[17:29:41.997]             }))
[17:29:41.997]             future::FutureResult(value = ...future.value$value, 
[17:29:41.997]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.997]                   ...future.rng), globalenv = if (FALSE) 
[17:29:41.997]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:41.997]                     ...future.globalenv.names))
[17:29:41.997]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:41.997]         }, condition = base::local({
[17:29:41.997]             c <- base::c
[17:29:41.997]             inherits <- base::inherits
[17:29:41.997]             invokeRestart <- base::invokeRestart
[17:29:41.997]             length <- base::length
[17:29:41.997]             list <- base::list
[17:29:41.997]             seq.int <- base::seq.int
[17:29:41.997]             signalCondition <- base::signalCondition
[17:29:41.997]             sys.calls <- base::sys.calls
[17:29:41.997]             `[[` <- base::`[[`
[17:29:41.997]             `+` <- base::`+`
[17:29:41.997]             `<<-` <- base::`<<-`
[17:29:41.997]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:41.997]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:41.997]                   3L)]
[17:29:41.997]             }
[17:29:41.997]             function(cond) {
[17:29:41.997]                 is_error <- inherits(cond, "error")
[17:29:41.997]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:41.997]                   NULL)
[17:29:41.997]                 if (is_error) {
[17:29:41.997]                   sessionInformation <- function() {
[17:29:41.997]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:41.997]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:41.997]                       search = base::search(), system = base::Sys.info())
[17:29:41.997]                   }
[17:29:41.997]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.997]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:41.997]                     cond$call), session = sessionInformation(), 
[17:29:41.997]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:41.997]                   signalCondition(cond)
[17:29:41.997]                 }
[17:29:41.997]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:41.997]                 "immediateCondition"))) {
[17:29:41.997]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:41.997]                   ...future.conditions[[length(...future.conditions) + 
[17:29:41.997]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:41.997]                   if (TRUE && !signal) {
[17:29:41.997]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.997]                     {
[17:29:41.997]                       inherits <- base::inherits
[17:29:41.997]                       invokeRestart <- base::invokeRestart
[17:29:41.997]                       is.null <- base::is.null
[17:29:41.997]                       muffled <- FALSE
[17:29:41.997]                       if (inherits(cond, "message")) {
[17:29:41.997]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.997]                         if (muffled) 
[17:29:41.997]                           invokeRestart("muffleMessage")
[17:29:41.997]                       }
[17:29:41.997]                       else if (inherits(cond, "warning")) {
[17:29:41.997]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.997]                         if (muffled) 
[17:29:41.997]                           invokeRestart("muffleWarning")
[17:29:41.997]                       }
[17:29:41.997]                       else if (inherits(cond, "condition")) {
[17:29:41.997]                         if (!is.null(pattern)) {
[17:29:41.997]                           computeRestarts <- base::computeRestarts
[17:29:41.997]                           grepl <- base::grepl
[17:29:41.997]                           restarts <- computeRestarts(cond)
[17:29:41.997]                           for (restart in restarts) {
[17:29:41.997]                             name <- restart$name
[17:29:41.997]                             if (is.null(name)) 
[17:29:41.997]                               next
[17:29:41.997]                             if (!grepl(pattern, name)) 
[17:29:41.997]                               next
[17:29:41.997]                             invokeRestart(restart)
[17:29:41.997]                             muffled <- TRUE
[17:29:41.997]                             break
[17:29:41.997]                           }
[17:29:41.997]                         }
[17:29:41.997]                       }
[17:29:41.997]                       invisible(muffled)
[17:29:41.997]                     }
[17:29:41.997]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.997]                   }
[17:29:41.997]                 }
[17:29:41.997]                 else {
[17:29:41.997]                   if (TRUE) {
[17:29:41.997]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:41.997]                     {
[17:29:41.997]                       inherits <- base::inherits
[17:29:41.997]                       invokeRestart <- base::invokeRestart
[17:29:41.997]                       is.null <- base::is.null
[17:29:41.997]                       muffled <- FALSE
[17:29:41.997]                       if (inherits(cond, "message")) {
[17:29:41.997]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:41.997]                         if (muffled) 
[17:29:41.997]                           invokeRestart("muffleMessage")
[17:29:41.997]                       }
[17:29:41.997]                       else if (inherits(cond, "warning")) {
[17:29:41.997]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:41.997]                         if (muffled) 
[17:29:41.997]                           invokeRestart("muffleWarning")
[17:29:41.997]                       }
[17:29:41.997]                       else if (inherits(cond, "condition")) {
[17:29:41.997]                         if (!is.null(pattern)) {
[17:29:41.997]                           computeRestarts <- base::computeRestarts
[17:29:41.997]                           grepl <- base::grepl
[17:29:41.997]                           restarts <- computeRestarts(cond)
[17:29:41.997]                           for (restart in restarts) {
[17:29:41.997]                             name <- restart$name
[17:29:41.997]                             if (is.null(name)) 
[17:29:41.997]                               next
[17:29:41.997]                             if (!grepl(pattern, name)) 
[17:29:41.997]                               next
[17:29:41.997]                             invokeRestart(restart)
[17:29:41.997]                             muffled <- TRUE
[17:29:41.997]                             break
[17:29:41.997]                           }
[17:29:41.997]                         }
[17:29:41.997]                       }
[17:29:41.997]                       invisible(muffled)
[17:29:41.997]                     }
[17:29:41.997]                     muffleCondition(cond, pattern = "^muffle")
[17:29:41.997]                   }
[17:29:41.997]                 }
[17:29:41.997]             }
[17:29:41.997]         }))
[17:29:41.997]     }, error = function(ex) {
[17:29:41.997]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:41.997]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:41.997]                 ...future.rng), started = ...future.startTime, 
[17:29:41.997]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:41.997]             version = "1.8"), class = "FutureResult")
[17:29:41.997]     }, finally = {
[17:29:41.997]         if (!identical(...future.workdir, getwd())) 
[17:29:41.997]             setwd(...future.workdir)
[17:29:41.997]         {
[17:29:41.997]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:41.997]                 ...future.oldOptions$nwarnings <- NULL
[17:29:41.997]             }
[17:29:41.997]             base::options(...future.oldOptions)
[17:29:41.997]             if (.Platform$OS.type == "windows") {
[17:29:41.997]                 old_names <- names(...future.oldEnvVars)
[17:29:41.997]                 envs <- base::Sys.getenv()
[17:29:41.997]                 names <- names(envs)
[17:29:41.997]                 common <- intersect(names, old_names)
[17:29:41.997]                 added <- setdiff(names, old_names)
[17:29:41.997]                 removed <- setdiff(old_names, names)
[17:29:41.997]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:41.997]                   envs[common]]
[17:29:41.997]                 NAMES <- toupper(changed)
[17:29:41.997]                 args <- list()
[17:29:41.997]                 for (kk in seq_along(NAMES)) {
[17:29:41.997]                   name <- changed[[kk]]
[17:29:41.997]                   NAME <- NAMES[[kk]]
[17:29:41.997]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.997]                     next
[17:29:41.997]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.997]                 }
[17:29:41.997]                 NAMES <- toupper(added)
[17:29:41.997]                 for (kk in seq_along(NAMES)) {
[17:29:41.997]                   name <- added[[kk]]
[17:29:41.997]                   NAME <- NAMES[[kk]]
[17:29:41.997]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.997]                     next
[17:29:41.997]                   args[[name]] <- ""
[17:29:41.997]                 }
[17:29:41.997]                 NAMES <- toupper(removed)
[17:29:41.997]                 for (kk in seq_along(NAMES)) {
[17:29:41.997]                   name <- removed[[kk]]
[17:29:41.997]                   NAME <- NAMES[[kk]]
[17:29:41.997]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:41.997]                     next
[17:29:41.997]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:41.997]                 }
[17:29:41.997]                 if (length(args) > 0) 
[17:29:41.997]                   base::do.call(base::Sys.setenv, args = args)
[17:29:41.997]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:41.997]             }
[17:29:41.997]             else {
[17:29:41.997]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:41.997]             }
[17:29:41.997]             {
[17:29:41.997]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:41.997]                   0L) {
[17:29:41.997]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:41.997]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:41.997]                   base::options(opts)
[17:29:41.997]                 }
[17:29:41.997]                 {
[17:29:41.997]                   {
[17:29:41.997]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:41.997]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:41.997]                     -1344458670L), envir = base::globalenv(), 
[17:29:41.997]                       inherits = FALSE)
[17:29:41.997]                     NULL
[17:29:41.997]                   }
[17:29:41.997]                   options(future.plan = NULL)
[17:29:41.997]                   if (is.na(NA_character_)) 
[17:29:41.997]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:41.997]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:41.997]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:41.997]                     .init = FALSE)
[17:29:41.997]                 }
[17:29:41.997]             }
[17:29:41.997]         }
[17:29:41.997]     })
[17:29:41.997]     if (TRUE) {
[17:29:41.997]         base::sink(type = "output", split = FALSE)
[17:29:41.997]         if (TRUE) {
[17:29:41.997]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:41.997]         }
[17:29:41.997]         else {
[17:29:41.997]             ...future.result["stdout"] <- base::list(NULL)
[17:29:41.997]         }
[17:29:41.997]         base::close(...future.stdout)
[17:29:41.997]         ...future.stdout <- NULL
[17:29:41.997]     }
[17:29:41.997]     ...future.result$conditions <- ...future.conditions
[17:29:41.997]     ...future.result$finished <- base::Sys.time()
[17:29:41.997]     ...future.result
[17:29:41.997] }
[17:29:42.001] assign_globals() ...
[17:29:42.001] List of 1
[17:29:42.001]  $ x: int [1:4] 0 1 2 3
[17:29:42.001]  - attr(*, "where")=List of 1
[17:29:42.001]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.001]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.001]  - attr(*, "resolved")= logi FALSE
[17:29:42.001]  - attr(*, "total_size")= int 133
[17:29:42.001]  - attr(*, "already-done")= logi TRUE
[17:29:42.009] - copied 'x' to environment
[17:29:42.009] assign_globals() ... done
[17:29:42.010] plan(): Setting new future strategy stack:
[17:29:42.010] List of future strategies:
[17:29:42.010] 1. sequential:
[17:29:42.010]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.010]    - tweaked: FALSE
[17:29:42.010]    - call: NULL
[17:29:42.011] plan(): nbrOfWorkers() = 1
[17:29:42.013] plan(): Setting new future strategy stack:
[17:29:42.014] List of future strategies:
[17:29:42.014] 1. sequential:
[17:29:42.014]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.014]    - tweaked: FALSE
[17:29:42.014]    - call: plan(strategy)
[17:29:42.014] plan(): nbrOfWorkers() = 1
[17:29:42.015] SequentialFuture started (and completed)
[17:29:42.015] - Launch lazy future ... done
[17:29:42.015] run() for 'SequentialFuture' ... done
[17:29:42.016] getGlobalsAndPackages() ...
[17:29:42.017] Searching for globals...
[17:29:42.018] - globals found: [3] '{', 'sample', 'x'
[17:29:42.019] Searching for globals ... DONE
[17:29:42.019] Resolving globals: FALSE
[17:29:42.020] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.020] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.021] - globals: [1] 'x'
[17:29:42.021] 
[17:29:42.021] getGlobalsAndPackages() ... DONE
[17:29:42.022] run() for 'Future' ...
[17:29:42.022] - state: 'created'
[17:29:42.022] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.023] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.023] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.023]   - Field: 'label'
[17:29:42.024]   - Field: 'local'
[17:29:42.024]   - Field: 'owner'
[17:29:42.024]   - Field: 'envir'
[17:29:42.024]   - Field: 'packages'
[17:29:42.025]   - Field: 'gc'
[17:29:42.025]   - Field: 'conditions'
[17:29:42.025]   - Field: 'expr'
[17:29:42.025]   - Field: 'uuid'
[17:29:42.026]   - Field: 'seed'
[17:29:42.026]   - Field: 'version'
[17:29:42.026]   - Field: 'result'
[17:29:42.026]   - Field: 'asynchronous'
[17:29:42.026]   - Field: 'calls'
[17:29:42.027]   - Field: 'globals'
[17:29:42.027]   - Field: 'stdout'
[17:29:42.027]   - Field: 'earlySignal'
[17:29:42.027]   - Field: 'lazy'
[17:29:42.028]   - Field: 'state'
[17:29:42.028] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.028] - Launch lazy future ...
[17:29:42.028] Packages needed by the future expression (n = 0): <none>
[17:29:42.029] Packages needed by future strategies (n = 0): <none>
[17:29:42.030] {
[17:29:42.030]     {
[17:29:42.030]         {
[17:29:42.030]             ...future.startTime <- base::Sys.time()
[17:29:42.030]             {
[17:29:42.030]                 {
[17:29:42.030]                   {
[17:29:42.030]                     {
[17:29:42.030]                       base::local({
[17:29:42.030]                         has_future <- base::requireNamespace("future", 
[17:29:42.030]                           quietly = TRUE)
[17:29:42.030]                         if (has_future) {
[17:29:42.030]                           ns <- base::getNamespace("future")
[17:29:42.030]                           version <- ns[[".package"]][["version"]]
[17:29:42.030]                           if (is.null(version)) 
[17:29:42.030]                             version <- utils::packageVersion("future")
[17:29:42.030]                         }
[17:29:42.030]                         else {
[17:29:42.030]                           version <- NULL
[17:29:42.030]                         }
[17:29:42.030]                         if (!has_future || version < "1.8.0") {
[17:29:42.030]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.030]                             "", base::R.version$version.string), 
[17:29:42.030]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:42.030]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.030]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.030]                               "release", "version")], collapse = " "), 
[17:29:42.030]                             hostname = base::Sys.info()[["nodename"]])
[17:29:42.030]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.030]                             info)
[17:29:42.030]                           info <- base::paste(info, collapse = "; ")
[17:29:42.030]                           if (!has_future) {
[17:29:42.030]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.030]                               info)
[17:29:42.030]                           }
[17:29:42.030]                           else {
[17:29:42.030]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.030]                               info, version)
[17:29:42.030]                           }
[17:29:42.030]                           base::stop(msg)
[17:29:42.030]                         }
[17:29:42.030]                       })
[17:29:42.030]                     }
[17:29:42.030]                     ...future.strategy.old <- future::plan("list")
[17:29:42.030]                     options(future.plan = NULL)
[17:29:42.030]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.030]                     future::plan("default", .cleanup = FALSE, 
[17:29:42.030]                       .init = FALSE)
[17:29:42.030]                   }
[17:29:42.030]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[17:29:42.030]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[17:29:42.030]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[17:29:42.030]                 }
[17:29:42.030]                 ...future.workdir <- getwd()
[17:29:42.030]             }
[17:29:42.030]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.030]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.030]         }
[17:29:42.030]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.030]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.030]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.030]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.030]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.030]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.030]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.030]             base::names(...future.oldOptions))
[17:29:42.030]     }
[17:29:42.030]     if (FALSE) {
[17:29:42.030]     }
[17:29:42.030]     else {
[17:29:42.030]         if (TRUE) {
[17:29:42.030]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.030]                 open = "w")
[17:29:42.030]         }
[17:29:42.030]         else {
[17:29:42.030]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.030]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.030]         }
[17:29:42.030]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.030]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.030]             base::sink(type = "output", split = FALSE)
[17:29:42.030]             base::close(...future.stdout)
[17:29:42.030]         }, add = TRUE)
[17:29:42.030]     }
[17:29:42.030]     ...future.frame <- base::sys.nframe()
[17:29:42.030]     ...future.conditions <- base::list()
[17:29:42.030]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.030]     if (FALSE) {
[17:29:42.030]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.030]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.030]     }
[17:29:42.030]     ...future.result <- base::tryCatch({
[17:29:42.030]         base::withCallingHandlers({
[17:29:42.030]             ...future.value <- base::withVisible(base::local({
[17:29:42.030]                 sample(x, size = 1L)
[17:29:42.030]             }))
[17:29:42.030]             future::FutureResult(value = ...future.value$value, 
[17:29:42.030]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.030]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.030]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.030]                     ...future.globalenv.names))
[17:29:42.030]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.030]         }, condition = base::local({
[17:29:42.030]             c <- base::c
[17:29:42.030]             inherits <- base::inherits
[17:29:42.030]             invokeRestart <- base::invokeRestart
[17:29:42.030]             length <- base::length
[17:29:42.030]             list <- base::list
[17:29:42.030]             seq.int <- base::seq.int
[17:29:42.030]             signalCondition <- base::signalCondition
[17:29:42.030]             sys.calls <- base::sys.calls
[17:29:42.030]             `[[` <- base::`[[`
[17:29:42.030]             `+` <- base::`+`
[17:29:42.030]             `<<-` <- base::`<<-`
[17:29:42.030]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.030]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.030]                   3L)]
[17:29:42.030]             }
[17:29:42.030]             function(cond) {
[17:29:42.030]                 is_error <- inherits(cond, "error")
[17:29:42.030]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.030]                   NULL)
[17:29:42.030]                 if (is_error) {
[17:29:42.030]                   sessionInformation <- function() {
[17:29:42.030]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.030]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.030]                       search = base::search(), system = base::Sys.info())
[17:29:42.030]                   }
[17:29:42.030]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.030]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.030]                     cond$call), session = sessionInformation(), 
[17:29:42.030]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.030]                   signalCondition(cond)
[17:29:42.030]                 }
[17:29:42.030]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.030]                 "immediateCondition"))) {
[17:29:42.030]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.030]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.030]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.030]                   if (TRUE && !signal) {
[17:29:42.030]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.030]                     {
[17:29:42.030]                       inherits <- base::inherits
[17:29:42.030]                       invokeRestart <- base::invokeRestart
[17:29:42.030]                       is.null <- base::is.null
[17:29:42.030]                       muffled <- FALSE
[17:29:42.030]                       if (inherits(cond, "message")) {
[17:29:42.030]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.030]                         if (muffled) 
[17:29:42.030]                           invokeRestart("muffleMessage")
[17:29:42.030]                       }
[17:29:42.030]                       else if (inherits(cond, "warning")) {
[17:29:42.030]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.030]                         if (muffled) 
[17:29:42.030]                           invokeRestart("muffleWarning")
[17:29:42.030]                       }
[17:29:42.030]                       else if (inherits(cond, "condition")) {
[17:29:42.030]                         if (!is.null(pattern)) {
[17:29:42.030]                           computeRestarts <- base::computeRestarts
[17:29:42.030]                           grepl <- base::grepl
[17:29:42.030]                           restarts <- computeRestarts(cond)
[17:29:42.030]                           for (restart in restarts) {
[17:29:42.030]                             name <- restart$name
[17:29:42.030]                             if (is.null(name)) 
[17:29:42.030]                               next
[17:29:42.030]                             if (!grepl(pattern, name)) 
[17:29:42.030]                               next
[17:29:42.030]                             invokeRestart(restart)
[17:29:42.030]                             muffled <- TRUE
[17:29:42.030]                             break
[17:29:42.030]                           }
[17:29:42.030]                         }
[17:29:42.030]                       }
[17:29:42.030]                       invisible(muffled)
[17:29:42.030]                     }
[17:29:42.030]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.030]                   }
[17:29:42.030]                 }
[17:29:42.030]                 else {
[17:29:42.030]                   if (TRUE) {
[17:29:42.030]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.030]                     {
[17:29:42.030]                       inherits <- base::inherits
[17:29:42.030]                       invokeRestart <- base::invokeRestart
[17:29:42.030]                       is.null <- base::is.null
[17:29:42.030]                       muffled <- FALSE
[17:29:42.030]                       if (inherits(cond, "message")) {
[17:29:42.030]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.030]                         if (muffled) 
[17:29:42.030]                           invokeRestart("muffleMessage")
[17:29:42.030]                       }
[17:29:42.030]                       else if (inherits(cond, "warning")) {
[17:29:42.030]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.030]                         if (muffled) 
[17:29:42.030]                           invokeRestart("muffleWarning")
[17:29:42.030]                       }
[17:29:42.030]                       else if (inherits(cond, "condition")) {
[17:29:42.030]                         if (!is.null(pattern)) {
[17:29:42.030]                           computeRestarts <- base::computeRestarts
[17:29:42.030]                           grepl <- base::grepl
[17:29:42.030]                           restarts <- computeRestarts(cond)
[17:29:42.030]                           for (restart in restarts) {
[17:29:42.030]                             name <- restart$name
[17:29:42.030]                             if (is.null(name)) 
[17:29:42.030]                               next
[17:29:42.030]                             if (!grepl(pattern, name)) 
[17:29:42.030]                               next
[17:29:42.030]                             invokeRestart(restart)
[17:29:42.030]                             muffled <- TRUE
[17:29:42.030]                             break
[17:29:42.030]                           }
[17:29:42.030]                         }
[17:29:42.030]                       }
[17:29:42.030]                       invisible(muffled)
[17:29:42.030]                     }
[17:29:42.030]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.030]                   }
[17:29:42.030]                 }
[17:29:42.030]             }
[17:29:42.030]         }))
[17:29:42.030]     }, error = function(ex) {
[17:29:42.030]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.030]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.030]                 ...future.rng), started = ...future.startTime, 
[17:29:42.030]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.030]             version = "1.8"), class = "FutureResult")
[17:29:42.030]     }, finally = {
[17:29:42.030]         if (!identical(...future.workdir, getwd())) 
[17:29:42.030]             setwd(...future.workdir)
[17:29:42.030]         {
[17:29:42.030]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.030]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.030]             }
[17:29:42.030]             base::options(...future.oldOptions)
[17:29:42.030]             if (.Platform$OS.type == "windows") {
[17:29:42.030]                 old_names <- names(...future.oldEnvVars)
[17:29:42.030]                 envs <- base::Sys.getenv()
[17:29:42.030]                 names <- names(envs)
[17:29:42.030]                 common <- intersect(names, old_names)
[17:29:42.030]                 added <- setdiff(names, old_names)
[17:29:42.030]                 removed <- setdiff(old_names, names)
[17:29:42.030]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.030]                   envs[common]]
[17:29:42.030]                 NAMES <- toupper(changed)
[17:29:42.030]                 args <- list()
[17:29:42.030]                 for (kk in seq_along(NAMES)) {
[17:29:42.030]                   name <- changed[[kk]]
[17:29:42.030]                   NAME <- NAMES[[kk]]
[17:29:42.030]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.030]                     next
[17:29:42.030]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.030]                 }
[17:29:42.030]                 NAMES <- toupper(added)
[17:29:42.030]                 for (kk in seq_along(NAMES)) {
[17:29:42.030]                   name <- added[[kk]]
[17:29:42.030]                   NAME <- NAMES[[kk]]
[17:29:42.030]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.030]                     next
[17:29:42.030]                   args[[name]] <- ""
[17:29:42.030]                 }
[17:29:42.030]                 NAMES <- toupper(removed)
[17:29:42.030]                 for (kk in seq_along(NAMES)) {
[17:29:42.030]                   name <- removed[[kk]]
[17:29:42.030]                   NAME <- NAMES[[kk]]
[17:29:42.030]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.030]                     next
[17:29:42.030]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.030]                 }
[17:29:42.030]                 if (length(args) > 0) 
[17:29:42.030]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.030]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.030]             }
[17:29:42.030]             else {
[17:29:42.030]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.030]             }
[17:29:42.030]             {
[17:29:42.030]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.030]                   0L) {
[17:29:42.030]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.030]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.030]                   base::options(opts)
[17:29:42.030]                 }
[17:29:42.030]                 {
[17:29:42.030]                   {
[17:29:42.030]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:42.030]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:42.030]                     -1344458670L), envir = base::globalenv(), 
[17:29:42.030]                       inherits = FALSE)
[17:29:42.030]                     NULL
[17:29:42.030]                   }
[17:29:42.030]                   options(future.plan = NULL)
[17:29:42.030]                   if (is.na(NA_character_)) 
[17:29:42.030]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.030]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.030]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.030]                     .init = FALSE)
[17:29:42.030]                 }
[17:29:42.030]             }
[17:29:42.030]         }
[17:29:42.030]     })
[17:29:42.030]     if (TRUE) {
[17:29:42.030]         base::sink(type = "output", split = FALSE)
[17:29:42.030]         if (TRUE) {
[17:29:42.030]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.030]         }
[17:29:42.030]         else {
[17:29:42.030]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.030]         }
[17:29:42.030]         base::close(...future.stdout)
[17:29:42.030]         ...future.stdout <- NULL
[17:29:42.030]     }
[17:29:42.030]     ...future.result$conditions <- ...future.conditions
[17:29:42.030]     ...future.result$finished <- base::Sys.time()
[17:29:42.030]     ...future.result
[17:29:42.030] }
[17:29:42.035] assign_globals() ...
[17:29:42.036] List of 1
[17:29:42.036]  $ x: int [1:4] 0 1 2 3
[17:29:42.036]  - attr(*, "where")=List of 1
[17:29:42.036]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.036]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.036]  - attr(*, "resolved")= logi FALSE
[17:29:42.036]  - attr(*, "total_size")= int 133
[17:29:42.036]  - attr(*, "already-done")= logi TRUE
[17:29:42.040] - copied 'x' to environment
[17:29:42.040] assign_globals() ... done
[17:29:42.041] plan(): Setting new future strategy stack:
[17:29:42.041] List of future strategies:
[17:29:42.041] 1. sequential:
[17:29:42.041]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.041]    - tweaked: FALSE
[17:29:42.041]    - call: NULL
[17:29:42.042] plan(): nbrOfWorkers() = 1
[17:29:42.044] plan(): Setting new future strategy stack:
[17:29:42.044] List of future strategies:
[17:29:42.044] 1. sequential:
[17:29:42.044]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.044]    - tweaked: FALSE
[17:29:42.044]    - call: plan(strategy)
[17:29:42.045] plan(): nbrOfWorkers() = 1
[17:29:42.046] SequentialFuture started (and completed)
[17:29:42.046] - Launch lazy future ... done
[17:29:42.046] run() for 'SequentialFuture' ... done
[17:29:42.047] getGlobalsAndPackages() ...
[17:29:42.047] Searching for globals...
[17:29:42.052] - globals found: [3] '{', 'sample', 'x'
[17:29:42.052] Searching for globals ... DONE
[17:29:42.053] Resolving globals: FALSE
[17:29:42.053] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.054] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.054] - globals: [1] 'x'
[17:29:42.055] 
[17:29:42.055] getGlobalsAndPackages() ... DONE
[17:29:42.056] run() for 'Future' ...
[17:29:42.056] - state: 'created'
[17:29:42.056] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.057] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.057] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.057]   - Field: 'label'
[17:29:42.058]   - Field: 'local'
[17:29:42.058]   - Field: 'owner'
[17:29:42.058]   - Field: 'envir'
[17:29:42.059]   - Field: 'packages'
[17:29:42.059]   - Field: 'gc'
[17:29:42.059]   - Field: 'conditions'
[17:29:42.059]   - Field: 'expr'
[17:29:42.060]   - Field: 'uuid'
[17:29:42.060]   - Field: 'seed'
[17:29:42.060]   - Field: 'version'
[17:29:42.061]   - Field: 'result'
[17:29:42.061]   - Field: 'asynchronous'
[17:29:42.061]   - Field: 'calls'
[17:29:42.061]   - Field: 'globals'
[17:29:42.062]   - Field: 'stdout'
[17:29:42.062]   - Field: 'earlySignal'
[17:29:42.062]   - Field: 'lazy'
[17:29:42.062]   - Field: 'state'
[17:29:42.063] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.063] - Launch lazy future ...
[17:29:42.063] Packages needed by the future expression (n = 0): <none>
[17:29:42.064] Packages needed by future strategies (n = 0): <none>
[17:29:42.065] {
[17:29:42.065]     {
[17:29:42.065]         {
[17:29:42.065]             ...future.startTime <- base::Sys.time()
[17:29:42.065]             {
[17:29:42.065]                 {
[17:29:42.065]                   {
[17:29:42.065]                     {
[17:29:42.065]                       base::local({
[17:29:42.065]                         has_future <- base::requireNamespace("future", 
[17:29:42.065]                           quietly = TRUE)
[17:29:42.065]                         if (has_future) {
[17:29:42.065]                           ns <- base::getNamespace("future")
[17:29:42.065]                           version <- ns[[".package"]][["version"]]
[17:29:42.065]                           if (is.null(version)) 
[17:29:42.065]                             version <- utils::packageVersion("future")
[17:29:42.065]                         }
[17:29:42.065]                         else {
[17:29:42.065]                           version <- NULL
[17:29:42.065]                         }
[17:29:42.065]                         if (!has_future || version < "1.8.0") {
[17:29:42.065]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.065]                             "", base::R.version$version.string), 
[17:29:42.065]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:42.065]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.065]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.065]                               "release", "version")], collapse = " "), 
[17:29:42.065]                             hostname = base::Sys.info()[["nodename"]])
[17:29:42.065]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.065]                             info)
[17:29:42.065]                           info <- base::paste(info, collapse = "; ")
[17:29:42.065]                           if (!has_future) {
[17:29:42.065]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.065]                               info)
[17:29:42.065]                           }
[17:29:42.065]                           else {
[17:29:42.065]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.065]                               info, version)
[17:29:42.065]                           }
[17:29:42.065]                           base::stop(msg)
[17:29:42.065]                         }
[17:29:42.065]                       })
[17:29:42.065]                     }
[17:29:42.065]                     ...future.strategy.old <- future::plan("list")
[17:29:42.065]                     options(future.plan = NULL)
[17:29:42.065]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.065]                     future::plan("default", .cleanup = FALSE, 
[17:29:42.065]                       .init = FALSE)
[17:29:42.065]                   }
[17:29:42.065]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[17:29:42.065]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[17:29:42.065]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[17:29:42.065]                 }
[17:29:42.065]                 ...future.workdir <- getwd()
[17:29:42.065]             }
[17:29:42.065]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.065]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.065]         }
[17:29:42.065]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.065]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.065]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.065]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.065]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.065]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.065]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.065]             base::names(...future.oldOptions))
[17:29:42.065]     }
[17:29:42.065]     if (FALSE) {
[17:29:42.065]     }
[17:29:42.065]     else {
[17:29:42.065]         if (TRUE) {
[17:29:42.065]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.065]                 open = "w")
[17:29:42.065]         }
[17:29:42.065]         else {
[17:29:42.065]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.065]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.065]         }
[17:29:42.065]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.065]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.065]             base::sink(type = "output", split = FALSE)
[17:29:42.065]             base::close(...future.stdout)
[17:29:42.065]         }, add = TRUE)
[17:29:42.065]     }
[17:29:42.065]     ...future.frame <- base::sys.nframe()
[17:29:42.065]     ...future.conditions <- base::list()
[17:29:42.065]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.065]     if (FALSE) {
[17:29:42.065]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.065]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.065]     }
[17:29:42.065]     ...future.result <- base::tryCatch({
[17:29:42.065]         base::withCallingHandlers({
[17:29:42.065]             ...future.value <- base::withVisible(base::local({
[17:29:42.065]                 sample(x, size = 1L)
[17:29:42.065]             }))
[17:29:42.065]             future::FutureResult(value = ...future.value$value, 
[17:29:42.065]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.065]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.065]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.065]                     ...future.globalenv.names))
[17:29:42.065]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.065]         }, condition = base::local({
[17:29:42.065]             c <- base::c
[17:29:42.065]             inherits <- base::inherits
[17:29:42.065]             invokeRestart <- base::invokeRestart
[17:29:42.065]             length <- base::length
[17:29:42.065]             list <- base::list
[17:29:42.065]             seq.int <- base::seq.int
[17:29:42.065]             signalCondition <- base::signalCondition
[17:29:42.065]             sys.calls <- base::sys.calls
[17:29:42.065]             `[[` <- base::`[[`
[17:29:42.065]             `+` <- base::`+`
[17:29:42.065]             `<<-` <- base::`<<-`
[17:29:42.065]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.065]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.065]                   3L)]
[17:29:42.065]             }
[17:29:42.065]             function(cond) {
[17:29:42.065]                 is_error <- inherits(cond, "error")
[17:29:42.065]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.065]                   NULL)
[17:29:42.065]                 if (is_error) {
[17:29:42.065]                   sessionInformation <- function() {
[17:29:42.065]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.065]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.065]                       search = base::search(), system = base::Sys.info())
[17:29:42.065]                   }
[17:29:42.065]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.065]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.065]                     cond$call), session = sessionInformation(), 
[17:29:42.065]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.065]                   signalCondition(cond)
[17:29:42.065]                 }
[17:29:42.065]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.065]                 "immediateCondition"))) {
[17:29:42.065]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.065]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.065]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.065]                   if (TRUE && !signal) {
[17:29:42.065]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.065]                     {
[17:29:42.065]                       inherits <- base::inherits
[17:29:42.065]                       invokeRestart <- base::invokeRestart
[17:29:42.065]                       is.null <- base::is.null
[17:29:42.065]                       muffled <- FALSE
[17:29:42.065]                       if (inherits(cond, "message")) {
[17:29:42.065]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.065]                         if (muffled) 
[17:29:42.065]                           invokeRestart("muffleMessage")
[17:29:42.065]                       }
[17:29:42.065]                       else if (inherits(cond, "warning")) {
[17:29:42.065]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.065]                         if (muffled) 
[17:29:42.065]                           invokeRestart("muffleWarning")
[17:29:42.065]                       }
[17:29:42.065]                       else if (inherits(cond, "condition")) {
[17:29:42.065]                         if (!is.null(pattern)) {
[17:29:42.065]                           computeRestarts <- base::computeRestarts
[17:29:42.065]                           grepl <- base::grepl
[17:29:42.065]                           restarts <- computeRestarts(cond)
[17:29:42.065]                           for (restart in restarts) {
[17:29:42.065]                             name <- restart$name
[17:29:42.065]                             if (is.null(name)) 
[17:29:42.065]                               next
[17:29:42.065]                             if (!grepl(pattern, name)) 
[17:29:42.065]                               next
[17:29:42.065]                             invokeRestart(restart)
[17:29:42.065]                             muffled <- TRUE
[17:29:42.065]                             break
[17:29:42.065]                           }
[17:29:42.065]                         }
[17:29:42.065]                       }
[17:29:42.065]                       invisible(muffled)
[17:29:42.065]                     }
[17:29:42.065]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.065]                   }
[17:29:42.065]                 }
[17:29:42.065]                 else {
[17:29:42.065]                   if (TRUE) {
[17:29:42.065]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.065]                     {
[17:29:42.065]                       inherits <- base::inherits
[17:29:42.065]                       invokeRestart <- base::invokeRestart
[17:29:42.065]                       is.null <- base::is.null
[17:29:42.065]                       muffled <- FALSE
[17:29:42.065]                       if (inherits(cond, "message")) {
[17:29:42.065]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.065]                         if (muffled) 
[17:29:42.065]                           invokeRestart("muffleMessage")
[17:29:42.065]                       }
[17:29:42.065]                       else if (inherits(cond, "warning")) {
[17:29:42.065]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.065]                         if (muffled) 
[17:29:42.065]                           invokeRestart("muffleWarning")
[17:29:42.065]                       }
[17:29:42.065]                       else if (inherits(cond, "condition")) {
[17:29:42.065]                         if (!is.null(pattern)) {
[17:29:42.065]                           computeRestarts <- base::computeRestarts
[17:29:42.065]                           grepl <- base::grepl
[17:29:42.065]                           restarts <- computeRestarts(cond)
[17:29:42.065]                           for (restart in restarts) {
[17:29:42.065]                             name <- restart$name
[17:29:42.065]                             if (is.null(name)) 
[17:29:42.065]                               next
[17:29:42.065]                             if (!grepl(pattern, name)) 
[17:29:42.065]                               next
[17:29:42.065]                             invokeRestart(restart)
[17:29:42.065]                             muffled <- TRUE
[17:29:42.065]                             break
[17:29:42.065]                           }
[17:29:42.065]                         }
[17:29:42.065]                       }
[17:29:42.065]                       invisible(muffled)
[17:29:42.065]                     }
[17:29:42.065]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.065]                   }
[17:29:42.065]                 }
[17:29:42.065]             }
[17:29:42.065]         }))
[17:29:42.065]     }, error = function(ex) {
[17:29:42.065]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.065]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.065]                 ...future.rng), started = ...future.startTime, 
[17:29:42.065]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.065]             version = "1.8"), class = "FutureResult")
[17:29:42.065]     }, finally = {
[17:29:42.065]         if (!identical(...future.workdir, getwd())) 
[17:29:42.065]             setwd(...future.workdir)
[17:29:42.065]         {
[17:29:42.065]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.065]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.065]             }
[17:29:42.065]             base::options(...future.oldOptions)
[17:29:42.065]             if (.Platform$OS.type == "windows") {
[17:29:42.065]                 old_names <- names(...future.oldEnvVars)
[17:29:42.065]                 envs <- base::Sys.getenv()
[17:29:42.065]                 names <- names(envs)
[17:29:42.065]                 common <- intersect(names, old_names)
[17:29:42.065]                 added <- setdiff(names, old_names)
[17:29:42.065]                 removed <- setdiff(old_names, names)
[17:29:42.065]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.065]                   envs[common]]
[17:29:42.065]                 NAMES <- toupper(changed)
[17:29:42.065]                 args <- list()
[17:29:42.065]                 for (kk in seq_along(NAMES)) {
[17:29:42.065]                   name <- changed[[kk]]
[17:29:42.065]                   NAME <- NAMES[[kk]]
[17:29:42.065]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.065]                     next
[17:29:42.065]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.065]                 }
[17:29:42.065]                 NAMES <- toupper(added)
[17:29:42.065]                 for (kk in seq_along(NAMES)) {
[17:29:42.065]                   name <- added[[kk]]
[17:29:42.065]                   NAME <- NAMES[[kk]]
[17:29:42.065]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.065]                     next
[17:29:42.065]                   args[[name]] <- ""
[17:29:42.065]                 }
[17:29:42.065]                 NAMES <- toupper(removed)
[17:29:42.065]                 for (kk in seq_along(NAMES)) {
[17:29:42.065]                   name <- removed[[kk]]
[17:29:42.065]                   NAME <- NAMES[[kk]]
[17:29:42.065]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.065]                     next
[17:29:42.065]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.065]                 }
[17:29:42.065]                 if (length(args) > 0) 
[17:29:42.065]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.065]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.065]             }
[17:29:42.065]             else {
[17:29:42.065]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.065]             }
[17:29:42.065]             {
[17:29:42.065]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.065]                   0L) {
[17:29:42.065]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.065]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.065]                   base::options(opts)
[17:29:42.065]                 }
[17:29:42.065]                 {
[17:29:42.065]                   {
[17:29:42.065]                     base::assign(".Random.seed", c(10407L, -2133391687L, 
[17:29:42.065]                     507561766L, 1260545903L, 1362917092L, -1772566379L, 
[17:29:42.065]                     -1344458670L), envir = base::globalenv(), 
[17:29:42.065]                       inherits = FALSE)
[17:29:42.065]                     NULL
[17:29:42.065]                   }
[17:29:42.065]                   options(future.plan = NULL)
[17:29:42.065]                   if (is.na(NA_character_)) 
[17:29:42.065]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.065]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.065]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.065]                     .init = FALSE)
[17:29:42.065]                 }
[17:29:42.065]             }
[17:29:42.065]         }
[17:29:42.065]     })
[17:29:42.065]     if (TRUE) {
[17:29:42.065]         base::sink(type = "output", split = FALSE)
[17:29:42.065]         if (TRUE) {
[17:29:42.065]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.065]         }
[17:29:42.065]         else {
[17:29:42.065]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.065]         }
[17:29:42.065]         base::close(...future.stdout)
[17:29:42.065]         ...future.stdout <- NULL
[17:29:42.065]     }
[17:29:42.065]     ...future.result$conditions <- ...future.conditions
[17:29:42.065]     ...future.result$finished <- base::Sys.time()
[17:29:42.065]     ...future.result
[17:29:42.065] }
[17:29:42.070] assign_globals() ...
[17:29:42.071] List of 1
[17:29:42.071]  $ x: int [1:4] 0 1 2 3
[17:29:42.071]  - attr(*, "where")=List of 1
[17:29:42.071]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.071]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.071]  - attr(*, "resolved")= logi FALSE
[17:29:42.071]  - attr(*, "total_size")= int 133
[17:29:42.071]  - attr(*, "already-done")= logi TRUE
[17:29:42.076] - copied 'x' to environment
[17:29:42.077] assign_globals() ... done
[17:29:42.077] plan(): Setting new future strategy stack:
[17:29:42.077] List of future strategies:
[17:29:42.077] 1. sequential:
[17:29:42.077]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.077]    - tweaked: FALSE
[17:29:42.077]    - call: NULL
[17:29:42.078] plan(): nbrOfWorkers() = 1
[17:29:42.080] plan(): Setting new future strategy stack:
[17:29:42.081] List of future strategies:
[17:29:42.081] 1. sequential:
[17:29:42.081]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.081]    - tweaked: FALSE
[17:29:42.081]    - call: plan(strategy)
[17:29:42.082] plan(): nbrOfWorkers() = 1
[17:29:42.082] SequentialFuture started (and completed)
[17:29:42.082] - Launch lazy future ... done
[17:29:42.083] run() for 'SequentialFuture' ... done
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[17:29:42.084] getGlobalsAndPackages() ...
[17:29:42.085] Searching for globals...
[17:29:42.087] - globals found: [3] '{', 'sample', 'x'
[17:29:42.087] Searching for globals ... DONE
[17:29:42.087] Resolving globals: FALSE
[17:29:42.088] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.088] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.089] - globals: [1] 'x'
[17:29:42.089] 
[17:29:42.089] getGlobalsAndPackages() ... DONE
[17:29:42.090] run() for 'Future' ...
[17:29:42.090] - state: 'created'
[17:29:42.090] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.091] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.091] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.092]   - Field: 'label'
[17:29:42.092]   - Field: 'local'
[17:29:42.092]   - Field: 'owner'
[17:29:42.092]   - Field: 'envir'
[17:29:42.093]   - Field: 'packages'
[17:29:42.093]   - Field: 'gc'
[17:29:42.093]   - Field: 'conditions'
[17:29:42.093]   - Field: 'expr'
[17:29:42.094]   - Field: 'uuid'
[17:29:42.094]   - Field: 'seed'
[17:29:42.094]   - Field: 'version'
[17:29:42.094]   - Field: 'result'
[17:29:42.095]   - Field: 'asynchronous'
[17:29:42.095]   - Field: 'calls'
[17:29:42.095]   - Field: 'globals'
[17:29:42.096]   - Field: 'stdout'
[17:29:42.096]   - Field: 'earlySignal'
[17:29:42.096]   - Field: 'lazy'
[17:29:42.096]   - Field: 'state'
[17:29:42.097] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.097] - Launch lazy future ...
[17:29:42.097] Packages needed by the future expression (n = 0): <none>
[17:29:42.098] Packages needed by future strategies (n = 0): <none>
[17:29:42.101] {
[17:29:42.101]     {
[17:29:42.101]         {
[17:29:42.101]             ...future.startTime <- base::Sys.time()
[17:29:42.101]             {
[17:29:42.101]                 {
[17:29:42.101]                   {
[17:29:42.101]                     base::local({
[17:29:42.101]                       has_future <- base::requireNamespace("future", 
[17:29:42.101]                         quietly = TRUE)
[17:29:42.101]                       if (has_future) {
[17:29:42.101]                         ns <- base::getNamespace("future")
[17:29:42.101]                         version <- ns[[".package"]][["version"]]
[17:29:42.101]                         if (is.null(version)) 
[17:29:42.101]                           version <- utils::packageVersion("future")
[17:29:42.101]                       }
[17:29:42.101]                       else {
[17:29:42.101]                         version <- NULL
[17:29:42.101]                       }
[17:29:42.101]                       if (!has_future || version < "1.8.0") {
[17:29:42.101]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.101]                           "", base::R.version$version.string), 
[17:29:42.101]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.101]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.101]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.101]                             "release", "version")], collapse = " "), 
[17:29:42.101]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.101]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.101]                           info)
[17:29:42.101]                         info <- base::paste(info, collapse = "; ")
[17:29:42.101]                         if (!has_future) {
[17:29:42.101]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.101]                             info)
[17:29:42.101]                         }
[17:29:42.101]                         else {
[17:29:42.101]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.101]                             info, version)
[17:29:42.101]                         }
[17:29:42.101]                         base::stop(msg)
[17:29:42.101]                       }
[17:29:42.101]                     })
[17:29:42.101]                   }
[17:29:42.101]                   ...future.strategy.old <- future::plan("list")
[17:29:42.101]                   options(future.plan = NULL)
[17:29:42.101]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.101]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.101]                 }
[17:29:42.101]                 ...future.workdir <- getwd()
[17:29:42.101]             }
[17:29:42.101]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.101]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.101]         }
[17:29:42.101]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.101]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.101]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.101]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.101]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.101]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.101]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.101]             base::names(...future.oldOptions))
[17:29:42.101]     }
[17:29:42.101]     if (FALSE) {
[17:29:42.101]     }
[17:29:42.101]     else {
[17:29:42.101]         if (TRUE) {
[17:29:42.101]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.101]                 open = "w")
[17:29:42.101]         }
[17:29:42.101]         else {
[17:29:42.101]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.101]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.101]         }
[17:29:42.101]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.101]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.101]             base::sink(type = "output", split = FALSE)
[17:29:42.101]             base::close(...future.stdout)
[17:29:42.101]         }, add = TRUE)
[17:29:42.101]     }
[17:29:42.101]     ...future.frame <- base::sys.nframe()
[17:29:42.101]     ...future.conditions <- base::list()
[17:29:42.101]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.101]     if (FALSE) {
[17:29:42.101]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.101]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.101]     }
[17:29:42.101]     ...future.result <- base::tryCatch({
[17:29:42.101]         base::withCallingHandlers({
[17:29:42.101]             ...future.value <- base::withVisible(base::local({
[17:29:42.101]                 sample(x, size = 1L)
[17:29:42.101]             }))
[17:29:42.101]             future::FutureResult(value = ...future.value$value, 
[17:29:42.101]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.101]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.101]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.101]                     ...future.globalenv.names))
[17:29:42.101]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.101]         }, condition = base::local({
[17:29:42.101]             c <- base::c
[17:29:42.101]             inherits <- base::inherits
[17:29:42.101]             invokeRestart <- base::invokeRestart
[17:29:42.101]             length <- base::length
[17:29:42.101]             list <- base::list
[17:29:42.101]             seq.int <- base::seq.int
[17:29:42.101]             signalCondition <- base::signalCondition
[17:29:42.101]             sys.calls <- base::sys.calls
[17:29:42.101]             `[[` <- base::`[[`
[17:29:42.101]             `+` <- base::`+`
[17:29:42.101]             `<<-` <- base::`<<-`
[17:29:42.101]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.101]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.101]                   3L)]
[17:29:42.101]             }
[17:29:42.101]             function(cond) {
[17:29:42.101]                 is_error <- inherits(cond, "error")
[17:29:42.101]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.101]                   NULL)
[17:29:42.101]                 if (is_error) {
[17:29:42.101]                   sessionInformation <- function() {
[17:29:42.101]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.101]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.101]                       search = base::search(), system = base::Sys.info())
[17:29:42.101]                   }
[17:29:42.101]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.101]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.101]                     cond$call), session = sessionInformation(), 
[17:29:42.101]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.101]                   signalCondition(cond)
[17:29:42.101]                 }
[17:29:42.101]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.101]                 "immediateCondition"))) {
[17:29:42.101]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.101]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.101]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.101]                   if (TRUE && !signal) {
[17:29:42.101]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.101]                     {
[17:29:42.101]                       inherits <- base::inherits
[17:29:42.101]                       invokeRestart <- base::invokeRestart
[17:29:42.101]                       is.null <- base::is.null
[17:29:42.101]                       muffled <- FALSE
[17:29:42.101]                       if (inherits(cond, "message")) {
[17:29:42.101]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.101]                         if (muffled) 
[17:29:42.101]                           invokeRestart("muffleMessage")
[17:29:42.101]                       }
[17:29:42.101]                       else if (inherits(cond, "warning")) {
[17:29:42.101]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.101]                         if (muffled) 
[17:29:42.101]                           invokeRestart("muffleWarning")
[17:29:42.101]                       }
[17:29:42.101]                       else if (inherits(cond, "condition")) {
[17:29:42.101]                         if (!is.null(pattern)) {
[17:29:42.101]                           computeRestarts <- base::computeRestarts
[17:29:42.101]                           grepl <- base::grepl
[17:29:42.101]                           restarts <- computeRestarts(cond)
[17:29:42.101]                           for (restart in restarts) {
[17:29:42.101]                             name <- restart$name
[17:29:42.101]                             if (is.null(name)) 
[17:29:42.101]                               next
[17:29:42.101]                             if (!grepl(pattern, name)) 
[17:29:42.101]                               next
[17:29:42.101]                             invokeRestart(restart)
[17:29:42.101]                             muffled <- TRUE
[17:29:42.101]                             break
[17:29:42.101]                           }
[17:29:42.101]                         }
[17:29:42.101]                       }
[17:29:42.101]                       invisible(muffled)
[17:29:42.101]                     }
[17:29:42.101]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.101]                   }
[17:29:42.101]                 }
[17:29:42.101]                 else {
[17:29:42.101]                   if (TRUE) {
[17:29:42.101]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.101]                     {
[17:29:42.101]                       inherits <- base::inherits
[17:29:42.101]                       invokeRestart <- base::invokeRestart
[17:29:42.101]                       is.null <- base::is.null
[17:29:42.101]                       muffled <- FALSE
[17:29:42.101]                       if (inherits(cond, "message")) {
[17:29:42.101]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.101]                         if (muffled) 
[17:29:42.101]                           invokeRestart("muffleMessage")
[17:29:42.101]                       }
[17:29:42.101]                       else if (inherits(cond, "warning")) {
[17:29:42.101]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.101]                         if (muffled) 
[17:29:42.101]                           invokeRestart("muffleWarning")
[17:29:42.101]                       }
[17:29:42.101]                       else if (inherits(cond, "condition")) {
[17:29:42.101]                         if (!is.null(pattern)) {
[17:29:42.101]                           computeRestarts <- base::computeRestarts
[17:29:42.101]                           grepl <- base::grepl
[17:29:42.101]                           restarts <- computeRestarts(cond)
[17:29:42.101]                           for (restart in restarts) {
[17:29:42.101]                             name <- restart$name
[17:29:42.101]                             if (is.null(name)) 
[17:29:42.101]                               next
[17:29:42.101]                             if (!grepl(pattern, name)) 
[17:29:42.101]                               next
[17:29:42.101]                             invokeRestart(restart)
[17:29:42.101]                             muffled <- TRUE
[17:29:42.101]                             break
[17:29:42.101]                           }
[17:29:42.101]                         }
[17:29:42.101]                       }
[17:29:42.101]                       invisible(muffled)
[17:29:42.101]                     }
[17:29:42.101]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.101]                   }
[17:29:42.101]                 }
[17:29:42.101]             }
[17:29:42.101]         }))
[17:29:42.101]     }, error = function(ex) {
[17:29:42.101]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.101]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.101]                 ...future.rng), started = ...future.startTime, 
[17:29:42.101]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.101]             version = "1.8"), class = "FutureResult")
[17:29:42.101]     }, finally = {
[17:29:42.101]         if (!identical(...future.workdir, getwd())) 
[17:29:42.101]             setwd(...future.workdir)
[17:29:42.101]         {
[17:29:42.101]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.101]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.101]             }
[17:29:42.101]             base::options(...future.oldOptions)
[17:29:42.101]             if (.Platform$OS.type == "windows") {
[17:29:42.101]                 old_names <- names(...future.oldEnvVars)
[17:29:42.101]                 envs <- base::Sys.getenv()
[17:29:42.101]                 names <- names(envs)
[17:29:42.101]                 common <- intersect(names, old_names)
[17:29:42.101]                 added <- setdiff(names, old_names)
[17:29:42.101]                 removed <- setdiff(old_names, names)
[17:29:42.101]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.101]                   envs[common]]
[17:29:42.101]                 NAMES <- toupper(changed)
[17:29:42.101]                 args <- list()
[17:29:42.101]                 for (kk in seq_along(NAMES)) {
[17:29:42.101]                   name <- changed[[kk]]
[17:29:42.101]                   NAME <- NAMES[[kk]]
[17:29:42.101]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.101]                     next
[17:29:42.101]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.101]                 }
[17:29:42.101]                 NAMES <- toupper(added)
[17:29:42.101]                 for (kk in seq_along(NAMES)) {
[17:29:42.101]                   name <- added[[kk]]
[17:29:42.101]                   NAME <- NAMES[[kk]]
[17:29:42.101]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.101]                     next
[17:29:42.101]                   args[[name]] <- ""
[17:29:42.101]                 }
[17:29:42.101]                 NAMES <- toupper(removed)
[17:29:42.101]                 for (kk in seq_along(NAMES)) {
[17:29:42.101]                   name <- removed[[kk]]
[17:29:42.101]                   NAME <- NAMES[[kk]]
[17:29:42.101]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.101]                     next
[17:29:42.101]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.101]                 }
[17:29:42.101]                 if (length(args) > 0) 
[17:29:42.101]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.101]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.101]             }
[17:29:42.101]             else {
[17:29:42.101]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.101]             }
[17:29:42.101]             {
[17:29:42.101]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.101]                   0L) {
[17:29:42.101]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.101]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.101]                   base::options(opts)
[17:29:42.101]                 }
[17:29:42.101]                 {
[17:29:42.101]                   {
[17:29:42.101]                     base::assign(".Random.seed", c(10407L, 947362787L, 
[17:29:42.101]                     719126051L, -2135816529L, 855306454L, 1265414195L, 
[17:29:42.101]                     1336165471L), envir = base::globalenv(), 
[17:29:42.101]                       inherits = FALSE)
[17:29:42.101]                     NULL
[17:29:42.101]                   }
[17:29:42.101]                   options(future.plan = NULL)
[17:29:42.101]                   if (is.na(NA_character_)) 
[17:29:42.101]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.101]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.101]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.101]                     .init = FALSE)
[17:29:42.101]                 }
[17:29:42.101]             }
[17:29:42.101]         }
[17:29:42.101]     })
[17:29:42.101]     if (TRUE) {
[17:29:42.101]         base::sink(type = "output", split = FALSE)
[17:29:42.101]         if (TRUE) {
[17:29:42.101]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.101]         }
[17:29:42.101]         else {
[17:29:42.101]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.101]         }
[17:29:42.101]         base::close(...future.stdout)
[17:29:42.101]         ...future.stdout <- NULL
[17:29:42.101]     }
[17:29:42.101]     ...future.result$conditions <- ...future.conditions
[17:29:42.101]     ...future.result$finished <- base::Sys.time()
[17:29:42.101]     ...future.result
[17:29:42.101] }
[17:29:42.107] assign_globals() ...
[17:29:42.107] List of 1
[17:29:42.107]  $ x: int [1:4] 0 1 2 3
[17:29:42.107]  - attr(*, "where")=List of 1
[17:29:42.107]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.107]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.107]  - attr(*, "resolved")= logi FALSE
[17:29:42.107]  - attr(*, "total_size")= int 133
[17:29:42.107]  - attr(*, "already-done")= logi TRUE
[17:29:42.113] - copied 'x' to environment
[17:29:42.113] assign_globals() ... done
[17:29:42.114] plan(): Setting new future strategy stack:
[17:29:42.114] List of future strategies:
[17:29:42.114] 1. sequential:
[17:29:42.114]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.114]    - tweaked: FALSE
[17:29:42.114]    - call: NULL
[17:29:42.115] plan(): nbrOfWorkers() = 1
[17:29:42.117] plan(): Setting new future strategy stack:
[17:29:42.117] List of future strategies:
[17:29:42.117] 1. sequential:
[17:29:42.117]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.117]    - tweaked: FALSE
[17:29:42.117]    - call: plan(strategy)
[17:29:42.118] plan(): nbrOfWorkers() = 1
[17:29:42.118] SequentialFuture started (and completed)
[17:29:42.118] - Launch lazy future ... done
[17:29:42.119] run() for 'SequentialFuture' ... done
[17:29:42.120] getGlobalsAndPackages() ...
[17:29:42.120] Searching for globals...
[17:29:42.122] - globals found: [3] '{', 'sample', 'x'
[17:29:42.122] Searching for globals ... DONE
[17:29:42.122] Resolving globals: FALSE
[17:29:42.123] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.124] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.124] - globals: [1] 'x'
[17:29:42.124] 
[17:29:42.124] getGlobalsAndPackages() ... DONE
[17:29:42.125] run() for 'Future' ...
[17:29:42.125] - state: 'created'
[17:29:42.125] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.126] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.126] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.127]   - Field: 'label'
[17:29:42.127]   - Field: 'local'
[17:29:42.127]   - Field: 'owner'
[17:29:42.127]   - Field: 'envir'
[17:29:42.128]   - Field: 'packages'
[17:29:42.128]   - Field: 'gc'
[17:29:42.128]   - Field: 'conditions'
[17:29:42.128]   - Field: 'expr'
[17:29:42.129]   - Field: 'uuid'
[17:29:42.129]   - Field: 'seed'
[17:29:42.129]   - Field: 'version'
[17:29:42.129]   - Field: 'result'
[17:29:42.130]   - Field: 'asynchronous'
[17:29:42.130]   - Field: 'calls'
[17:29:42.130]   - Field: 'globals'
[17:29:42.131]   - Field: 'stdout'
[17:29:42.131]   - Field: 'earlySignal'
[17:29:42.131]   - Field: 'lazy'
[17:29:42.131]   - Field: 'state'
[17:29:42.132] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.132] - Launch lazy future ...
[17:29:42.132] Packages needed by the future expression (n = 0): <none>
[17:29:42.133] Packages needed by future strategies (n = 0): <none>
[17:29:42.133] {
[17:29:42.133]     {
[17:29:42.133]         {
[17:29:42.133]             ...future.startTime <- base::Sys.time()
[17:29:42.133]             {
[17:29:42.133]                 {
[17:29:42.133]                   {
[17:29:42.133]                     base::local({
[17:29:42.133]                       has_future <- base::requireNamespace("future", 
[17:29:42.133]                         quietly = TRUE)
[17:29:42.133]                       if (has_future) {
[17:29:42.133]                         ns <- base::getNamespace("future")
[17:29:42.133]                         version <- ns[[".package"]][["version"]]
[17:29:42.133]                         if (is.null(version)) 
[17:29:42.133]                           version <- utils::packageVersion("future")
[17:29:42.133]                       }
[17:29:42.133]                       else {
[17:29:42.133]                         version <- NULL
[17:29:42.133]                       }
[17:29:42.133]                       if (!has_future || version < "1.8.0") {
[17:29:42.133]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.133]                           "", base::R.version$version.string), 
[17:29:42.133]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.133]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.133]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.133]                             "release", "version")], collapse = " "), 
[17:29:42.133]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.133]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.133]                           info)
[17:29:42.133]                         info <- base::paste(info, collapse = "; ")
[17:29:42.133]                         if (!has_future) {
[17:29:42.133]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.133]                             info)
[17:29:42.133]                         }
[17:29:42.133]                         else {
[17:29:42.133]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.133]                             info, version)
[17:29:42.133]                         }
[17:29:42.133]                         base::stop(msg)
[17:29:42.133]                       }
[17:29:42.133]                     })
[17:29:42.133]                   }
[17:29:42.133]                   ...future.strategy.old <- future::plan("list")
[17:29:42.133]                   options(future.plan = NULL)
[17:29:42.133]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.133]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.133]                 }
[17:29:42.133]                 ...future.workdir <- getwd()
[17:29:42.133]             }
[17:29:42.133]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.133]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.133]         }
[17:29:42.133]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.133]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.133]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.133]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.133]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.133]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.133]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.133]             base::names(...future.oldOptions))
[17:29:42.133]     }
[17:29:42.133]     if (FALSE) {
[17:29:42.133]     }
[17:29:42.133]     else {
[17:29:42.133]         if (TRUE) {
[17:29:42.133]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.133]                 open = "w")
[17:29:42.133]         }
[17:29:42.133]         else {
[17:29:42.133]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.133]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.133]         }
[17:29:42.133]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.133]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.133]             base::sink(type = "output", split = FALSE)
[17:29:42.133]             base::close(...future.stdout)
[17:29:42.133]         }, add = TRUE)
[17:29:42.133]     }
[17:29:42.133]     ...future.frame <- base::sys.nframe()
[17:29:42.133]     ...future.conditions <- base::list()
[17:29:42.133]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.133]     if (FALSE) {
[17:29:42.133]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.133]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.133]     }
[17:29:42.133]     ...future.result <- base::tryCatch({
[17:29:42.133]         base::withCallingHandlers({
[17:29:42.133]             ...future.value <- base::withVisible(base::local({
[17:29:42.133]                 sample(x, size = 1L)
[17:29:42.133]             }))
[17:29:42.133]             future::FutureResult(value = ...future.value$value, 
[17:29:42.133]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.133]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.133]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.133]                     ...future.globalenv.names))
[17:29:42.133]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.133]         }, condition = base::local({
[17:29:42.133]             c <- base::c
[17:29:42.133]             inherits <- base::inherits
[17:29:42.133]             invokeRestart <- base::invokeRestart
[17:29:42.133]             length <- base::length
[17:29:42.133]             list <- base::list
[17:29:42.133]             seq.int <- base::seq.int
[17:29:42.133]             signalCondition <- base::signalCondition
[17:29:42.133]             sys.calls <- base::sys.calls
[17:29:42.133]             `[[` <- base::`[[`
[17:29:42.133]             `+` <- base::`+`
[17:29:42.133]             `<<-` <- base::`<<-`
[17:29:42.133]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.133]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.133]                   3L)]
[17:29:42.133]             }
[17:29:42.133]             function(cond) {
[17:29:42.133]                 is_error <- inherits(cond, "error")
[17:29:42.133]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.133]                   NULL)
[17:29:42.133]                 if (is_error) {
[17:29:42.133]                   sessionInformation <- function() {
[17:29:42.133]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.133]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.133]                       search = base::search(), system = base::Sys.info())
[17:29:42.133]                   }
[17:29:42.133]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.133]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.133]                     cond$call), session = sessionInformation(), 
[17:29:42.133]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.133]                   signalCondition(cond)
[17:29:42.133]                 }
[17:29:42.133]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.133]                 "immediateCondition"))) {
[17:29:42.133]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.133]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.133]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.133]                   if (TRUE && !signal) {
[17:29:42.133]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.133]                     {
[17:29:42.133]                       inherits <- base::inherits
[17:29:42.133]                       invokeRestart <- base::invokeRestart
[17:29:42.133]                       is.null <- base::is.null
[17:29:42.133]                       muffled <- FALSE
[17:29:42.133]                       if (inherits(cond, "message")) {
[17:29:42.133]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.133]                         if (muffled) 
[17:29:42.133]                           invokeRestart("muffleMessage")
[17:29:42.133]                       }
[17:29:42.133]                       else if (inherits(cond, "warning")) {
[17:29:42.133]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.133]                         if (muffled) 
[17:29:42.133]                           invokeRestart("muffleWarning")
[17:29:42.133]                       }
[17:29:42.133]                       else if (inherits(cond, "condition")) {
[17:29:42.133]                         if (!is.null(pattern)) {
[17:29:42.133]                           computeRestarts <- base::computeRestarts
[17:29:42.133]                           grepl <- base::grepl
[17:29:42.133]                           restarts <- computeRestarts(cond)
[17:29:42.133]                           for (restart in restarts) {
[17:29:42.133]                             name <- restart$name
[17:29:42.133]                             if (is.null(name)) 
[17:29:42.133]                               next
[17:29:42.133]                             if (!grepl(pattern, name)) 
[17:29:42.133]                               next
[17:29:42.133]                             invokeRestart(restart)
[17:29:42.133]                             muffled <- TRUE
[17:29:42.133]                             break
[17:29:42.133]                           }
[17:29:42.133]                         }
[17:29:42.133]                       }
[17:29:42.133]                       invisible(muffled)
[17:29:42.133]                     }
[17:29:42.133]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.133]                   }
[17:29:42.133]                 }
[17:29:42.133]                 else {
[17:29:42.133]                   if (TRUE) {
[17:29:42.133]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.133]                     {
[17:29:42.133]                       inherits <- base::inherits
[17:29:42.133]                       invokeRestart <- base::invokeRestart
[17:29:42.133]                       is.null <- base::is.null
[17:29:42.133]                       muffled <- FALSE
[17:29:42.133]                       if (inherits(cond, "message")) {
[17:29:42.133]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.133]                         if (muffled) 
[17:29:42.133]                           invokeRestart("muffleMessage")
[17:29:42.133]                       }
[17:29:42.133]                       else if (inherits(cond, "warning")) {
[17:29:42.133]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.133]                         if (muffled) 
[17:29:42.133]                           invokeRestart("muffleWarning")
[17:29:42.133]                       }
[17:29:42.133]                       else if (inherits(cond, "condition")) {
[17:29:42.133]                         if (!is.null(pattern)) {
[17:29:42.133]                           computeRestarts <- base::computeRestarts
[17:29:42.133]                           grepl <- base::grepl
[17:29:42.133]                           restarts <- computeRestarts(cond)
[17:29:42.133]                           for (restart in restarts) {
[17:29:42.133]                             name <- restart$name
[17:29:42.133]                             if (is.null(name)) 
[17:29:42.133]                               next
[17:29:42.133]                             if (!grepl(pattern, name)) 
[17:29:42.133]                               next
[17:29:42.133]                             invokeRestart(restart)
[17:29:42.133]                             muffled <- TRUE
[17:29:42.133]                             break
[17:29:42.133]                           }
[17:29:42.133]                         }
[17:29:42.133]                       }
[17:29:42.133]                       invisible(muffled)
[17:29:42.133]                     }
[17:29:42.133]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.133]                   }
[17:29:42.133]                 }
[17:29:42.133]             }
[17:29:42.133]         }))
[17:29:42.133]     }, error = function(ex) {
[17:29:42.133]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.133]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.133]                 ...future.rng), started = ...future.startTime, 
[17:29:42.133]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.133]             version = "1.8"), class = "FutureResult")
[17:29:42.133]     }, finally = {
[17:29:42.133]         if (!identical(...future.workdir, getwd())) 
[17:29:42.133]             setwd(...future.workdir)
[17:29:42.133]         {
[17:29:42.133]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.133]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.133]             }
[17:29:42.133]             base::options(...future.oldOptions)
[17:29:42.133]             if (.Platform$OS.type == "windows") {
[17:29:42.133]                 old_names <- names(...future.oldEnvVars)
[17:29:42.133]                 envs <- base::Sys.getenv()
[17:29:42.133]                 names <- names(envs)
[17:29:42.133]                 common <- intersect(names, old_names)
[17:29:42.133]                 added <- setdiff(names, old_names)
[17:29:42.133]                 removed <- setdiff(old_names, names)
[17:29:42.133]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.133]                   envs[common]]
[17:29:42.133]                 NAMES <- toupper(changed)
[17:29:42.133]                 args <- list()
[17:29:42.133]                 for (kk in seq_along(NAMES)) {
[17:29:42.133]                   name <- changed[[kk]]
[17:29:42.133]                   NAME <- NAMES[[kk]]
[17:29:42.133]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.133]                     next
[17:29:42.133]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.133]                 }
[17:29:42.133]                 NAMES <- toupper(added)
[17:29:42.133]                 for (kk in seq_along(NAMES)) {
[17:29:42.133]                   name <- added[[kk]]
[17:29:42.133]                   NAME <- NAMES[[kk]]
[17:29:42.133]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.133]                     next
[17:29:42.133]                   args[[name]] <- ""
[17:29:42.133]                 }
[17:29:42.133]                 NAMES <- toupper(removed)
[17:29:42.133]                 for (kk in seq_along(NAMES)) {
[17:29:42.133]                   name <- removed[[kk]]
[17:29:42.133]                   NAME <- NAMES[[kk]]
[17:29:42.133]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.133]                     next
[17:29:42.133]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.133]                 }
[17:29:42.133]                 if (length(args) > 0) 
[17:29:42.133]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.133]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.133]             }
[17:29:42.133]             else {
[17:29:42.133]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.133]             }
[17:29:42.133]             {
[17:29:42.133]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.133]                   0L) {
[17:29:42.133]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.133]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.133]                   base::options(opts)
[17:29:42.133]                 }
[17:29:42.133]                 {
[17:29:42.133]                   {
[17:29:42.133]                     base::assign(".Random.seed", c(10407L, -2135816529L, 
[17:29:42.133]                     1859168897L, -440760210L, 1336165471L, 1864291132L, 
[17:29:42.133]                     -1294538296L), envir = base::globalenv(), 
[17:29:42.133]                       inherits = FALSE)
[17:29:42.133]                     NULL
[17:29:42.133]                   }
[17:29:42.133]                   options(future.plan = NULL)
[17:29:42.133]                   if (is.na(NA_character_)) 
[17:29:42.133]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.133]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.133]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.133]                     .init = FALSE)
[17:29:42.133]                 }
[17:29:42.133]             }
[17:29:42.133]         }
[17:29:42.133]     })
[17:29:42.133]     if (TRUE) {
[17:29:42.133]         base::sink(type = "output", split = FALSE)
[17:29:42.133]         if (TRUE) {
[17:29:42.133]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.133]         }
[17:29:42.133]         else {
[17:29:42.133]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.133]         }
[17:29:42.133]         base::close(...future.stdout)
[17:29:42.133]         ...future.stdout <- NULL
[17:29:42.133]     }
[17:29:42.133]     ...future.result$conditions <- ...future.conditions
[17:29:42.133]     ...future.result$finished <- base::Sys.time()
[17:29:42.133]     ...future.result
[17:29:42.133] }
[17:29:42.139] assign_globals() ...
[17:29:42.139] List of 1
[17:29:42.139]  $ x: int [1:4] 0 1 2 3
[17:29:42.139]  - attr(*, "where")=List of 1
[17:29:42.139]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.139]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.139]  - attr(*, "resolved")= logi FALSE
[17:29:42.139]  - attr(*, "total_size")= int 133
[17:29:42.139]  - attr(*, "already-done")= logi TRUE
[17:29:42.144] - copied 'x' to environment
[17:29:42.144] assign_globals() ... done
[17:29:42.145] plan(): Setting new future strategy stack:
[17:29:42.145] List of future strategies:
[17:29:42.145] 1. sequential:
[17:29:42.145]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.145]    - tweaked: FALSE
[17:29:42.145]    - call: NULL
[17:29:42.146] plan(): nbrOfWorkers() = 1
[17:29:42.148] plan(): Setting new future strategy stack:
[17:29:42.148] List of future strategies:
[17:29:42.148] 1. sequential:
[17:29:42.148]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.148]    - tweaked: FALSE
[17:29:42.148]    - call: plan(strategy)
[17:29:42.152] plan(): nbrOfWorkers() = 1
[17:29:42.153] SequentialFuture started (and completed)
[17:29:42.153] - Launch lazy future ... done
[17:29:42.153] run() for 'SequentialFuture' ... done
[17:29:42.154] getGlobalsAndPackages() ...
[17:29:42.154] Searching for globals...
[17:29:42.156] - globals found: [3] '{', 'sample', 'x'
[17:29:42.157] Searching for globals ... DONE
[17:29:42.157] Resolving globals: FALSE
[17:29:42.158] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.159] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.159] - globals: [1] 'x'
[17:29:42.159] 
[17:29:42.159] getGlobalsAndPackages() ... DONE
[17:29:42.160] run() for 'Future' ...
[17:29:42.160] - state: 'created'
[17:29:42.161] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.161] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.161] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.162]   - Field: 'label'
[17:29:42.162]   - Field: 'local'
[17:29:42.162]   - Field: 'owner'
[17:29:42.163]   - Field: 'envir'
[17:29:42.163]   - Field: 'packages'
[17:29:42.163]   - Field: 'gc'
[17:29:42.163]   - Field: 'conditions'
[17:29:42.164]   - Field: 'expr'
[17:29:42.164]   - Field: 'uuid'
[17:29:42.164]   - Field: 'seed'
[17:29:42.164]   - Field: 'version'
[17:29:42.165]   - Field: 'result'
[17:29:42.165]   - Field: 'asynchronous'
[17:29:42.165]   - Field: 'calls'
[17:29:42.165]   - Field: 'globals'
[17:29:42.166]   - Field: 'stdout'
[17:29:42.166]   - Field: 'earlySignal'
[17:29:42.166]   - Field: 'lazy'
[17:29:42.166]   - Field: 'state'
[17:29:42.167] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.167] - Launch lazy future ...
[17:29:42.167] Packages needed by the future expression (n = 0): <none>
[17:29:42.168] Packages needed by future strategies (n = 0): <none>
[17:29:42.169] {
[17:29:42.169]     {
[17:29:42.169]         {
[17:29:42.169]             ...future.startTime <- base::Sys.time()
[17:29:42.169]             {
[17:29:42.169]                 {
[17:29:42.169]                   {
[17:29:42.169]                     base::local({
[17:29:42.169]                       has_future <- base::requireNamespace("future", 
[17:29:42.169]                         quietly = TRUE)
[17:29:42.169]                       if (has_future) {
[17:29:42.169]                         ns <- base::getNamespace("future")
[17:29:42.169]                         version <- ns[[".package"]][["version"]]
[17:29:42.169]                         if (is.null(version)) 
[17:29:42.169]                           version <- utils::packageVersion("future")
[17:29:42.169]                       }
[17:29:42.169]                       else {
[17:29:42.169]                         version <- NULL
[17:29:42.169]                       }
[17:29:42.169]                       if (!has_future || version < "1.8.0") {
[17:29:42.169]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.169]                           "", base::R.version$version.string), 
[17:29:42.169]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.169]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.169]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.169]                             "release", "version")], collapse = " "), 
[17:29:42.169]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.169]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.169]                           info)
[17:29:42.169]                         info <- base::paste(info, collapse = "; ")
[17:29:42.169]                         if (!has_future) {
[17:29:42.169]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.169]                             info)
[17:29:42.169]                         }
[17:29:42.169]                         else {
[17:29:42.169]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.169]                             info, version)
[17:29:42.169]                         }
[17:29:42.169]                         base::stop(msg)
[17:29:42.169]                       }
[17:29:42.169]                     })
[17:29:42.169]                   }
[17:29:42.169]                   ...future.strategy.old <- future::plan("list")
[17:29:42.169]                   options(future.plan = NULL)
[17:29:42.169]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.169]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.169]                 }
[17:29:42.169]                 ...future.workdir <- getwd()
[17:29:42.169]             }
[17:29:42.169]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.169]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.169]         }
[17:29:42.169]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.169]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.169]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.169]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.169]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.169]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.169]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.169]             base::names(...future.oldOptions))
[17:29:42.169]     }
[17:29:42.169]     if (FALSE) {
[17:29:42.169]     }
[17:29:42.169]     else {
[17:29:42.169]         if (TRUE) {
[17:29:42.169]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.169]                 open = "w")
[17:29:42.169]         }
[17:29:42.169]         else {
[17:29:42.169]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.169]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.169]         }
[17:29:42.169]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.169]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.169]             base::sink(type = "output", split = FALSE)
[17:29:42.169]             base::close(...future.stdout)
[17:29:42.169]         }, add = TRUE)
[17:29:42.169]     }
[17:29:42.169]     ...future.frame <- base::sys.nframe()
[17:29:42.169]     ...future.conditions <- base::list()
[17:29:42.169]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.169]     if (FALSE) {
[17:29:42.169]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.169]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.169]     }
[17:29:42.169]     ...future.result <- base::tryCatch({
[17:29:42.169]         base::withCallingHandlers({
[17:29:42.169]             ...future.value <- base::withVisible(base::local({
[17:29:42.169]                 sample(x, size = 1L)
[17:29:42.169]             }))
[17:29:42.169]             future::FutureResult(value = ...future.value$value, 
[17:29:42.169]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.169]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.169]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.169]                     ...future.globalenv.names))
[17:29:42.169]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.169]         }, condition = base::local({
[17:29:42.169]             c <- base::c
[17:29:42.169]             inherits <- base::inherits
[17:29:42.169]             invokeRestart <- base::invokeRestart
[17:29:42.169]             length <- base::length
[17:29:42.169]             list <- base::list
[17:29:42.169]             seq.int <- base::seq.int
[17:29:42.169]             signalCondition <- base::signalCondition
[17:29:42.169]             sys.calls <- base::sys.calls
[17:29:42.169]             `[[` <- base::`[[`
[17:29:42.169]             `+` <- base::`+`
[17:29:42.169]             `<<-` <- base::`<<-`
[17:29:42.169]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.169]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.169]                   3L)]
[17:29:42.169]             }
[17:29:42.169]             function(cond) {
[17:29:42.169]                 is_error <- inherits(cond, "error")
[17:29:42.169]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.169]                   NULL)
[17:29:42.169]                 if (is_error) {
[17:29:42.169]                   sessionInformation <- function() {
[17:29:42.169]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.169]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.169]                       search = base::search(), system = base::Sys.info())
[17:29:42.169]                   }
[17:29:42.169]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.169]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.169]                     cond$call), session = sessionInformation(), 
[17:29:42.169]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.169]                   signalCondition(cond)
[17:29:42.169]                 }
[17:29:42.169]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.169]                 "immediateCondition"))) {
[17:29:42.169]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.169]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.169]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.169]                   if (TRUE && !signal) {
[17:29:42.169]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.169]                     {
[17:29:42.169]                       inherits <- base::inherits
[17:29:42.169]                       invokeRestart <- base::invokeRestart
[17:29:42.169]                       is.null <- base::is.null
[17:29:42.169]                       muffled <- FALSE
[17:29:42.169]                       if (inherits(cond, "message")) {
[17:29:42.169]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.169]                         if (muffled) 
[17:29:42.169]                           invokeRestart("muffleMessage")
[17:29:42.169]                       }
[17:29:42.169]                       else if (inherits(cond, "warning")) {
[17:29:42.169]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.169]                         if (muffled) 
[17:29:42.169]                           invokeRestart("muffleWarning")
[17:29:42.169]                       }
[17:29:42.169]                       else if (inherits(cond, "condition")) {
[17:29:42.169]                         if (!is.null(pattern)) {
[17:29:42.169]                           computeRestarts <- base::computeRestarts
[17:29:42.169]                           grepl <- base::grepl
[17:29:42.169]                           restarts <- computeRestarts(cond)
[17:29:42.169]                           for (restart in restarts) {
[17:29:42.169]                             name <- restart$name
[17:29:42.169]                             if (is.null(name)) 
[17:29:42.169]                               next
[17:29:42.169]                             if (!grepl(pattern, name)) 
[17:29:42.169]                               next
[17:29:42.169]                             invokeRestart(restart)
[17:29:42.169]                             muffled <- TRUE
[17:29:42.169]                             break
[17:29:42.169]                           }
[17:29:42.169]                         }
[17:29:42.169]                       }
[17:29:42.169]                       invisible(muffled)
[17:29:42.169]                     }
[17:29:42.169]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.169]                   }
[17:29:42.169]                 }
[17:29:42.169]                 else {
[17:29:42.169]                   if (TRUE) {
[17:29:42.169]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.169]                     {
[17:29:42.169]                       inherits <- base::inherits
[17:29:42.169]                       invokeRestart <- base::invokeRestart
[17:29:42.169]                       is.null <- base::is.null
[17:29:42.169]                       muffled <- FALSE
[17:29:42.169]                       if (inherits(cond, "message")) {
[17:29:42.169]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.169]                         if (muffled) 
[17:29:42.169]                           invokeRestart("muffleMessage")
[17:29:42.169]                       }
[17:29:42.169]                       else if (inherits(cond, "warning")) {
[17:29:42.169]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.169]                         if (muffled) 
[17:29:42.169]                           invokeRestart("muffleWarning")
[17:29:42.169]                       }
[17:29:42.169]                       else if (inherits(cond, "condition")) {
[17:29:42.169]                         if (!is.null(pattern)) {
[17:29:42.169]                           computeRestarts <- base::computeRestarts
[17:29:42.169]                           grepl <- base::grepl
[17:29:42.169]                           restarts <- computeRestarts(cond)
[17:29:42.169]                           for (restart in restarts) {
[17:29:42.169]                             name <- restart$name
[17:29:42.169]                             if (is.null(name)) 
[17:29:42.169]                               next
[17:29:42.169]                             if (!grepl(pattern, name)) 
[17:29:42.169]                               next
[17:29:42.169]                             invokeRestart(restart)
[17:29:42.169]                             muffled <- TRUE
[17:29:42.169]                             break
[17:29:42.169]                           }
[17:29:42.169]                         }
[17:29:42.169]                       }
[17:29:42.169]                       invisible(muffled)
[17:29:42.169]                     }
[17:29:42.169]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.169]                   }
[17:29:42.169]                 }
[17:29:42.169]             }
[17:29:42.169]         }))
[17:29:42.169]     }, error = function(ex) {
[17:29:42.169]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.169]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.169]                 ...future.rng), started = ...future.startTime, 
[17:29:42.169]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.169]             version = "1.8"), class = "FutureResult")
[17:29:42.169]     }, finally = {
[17:29:42.169]         if (!identical(...future.workdir, getwd())) 
[17:29:42.169]             setwd(...future.workdir)
[17:29:42.169]         {
[17:29:42.169]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.169]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.169]             }
[17:29:42.169]             base::options(...future.oldOptions)
[17:29:42.169]             if (.Platform$OS.type == "windows") {
[17:29:42.169]                 old_names <- names(...future.oldEnvVars)
[17:29:42.169]                 envs <- base::Sys.getenv()
[17:29:42.169]                 names <- names(envs)
[17:29:42.169]                 common <- intersect(names, old_names)
[17:29:42.169]                 added <- setdiff(names, old_names)
[17:29:42.169]                 removed <- setdiff(old_names, names)
[17:29:42.169]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.169]                   envs[common]]
[17:29:42.169]                 NAMES <- toupper(changed)
[17:29:42.169]                 args <- list()
[17:29:42.169]                 for (kk in seq_along(NAMES)) {
[17:29:42.169]                   name <- changed[[kk]]
[17:29:42.169]                   NAME <- NAMES[[kk]]
[17:29:42.169]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.169]                     next
[17:29:42.169]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.169]                 }
[17:29:42.169]                 NAMES <- toupper(added)
[17:29:42.169]                 for (kk in seq_along(NAMES)) {
[17:29:42.169]                   name <- added[[kk]]
[17:29:42.169]                   NAME <- NAMES[[kk]]
[17:29:42.169]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.169]                     next
[17:29:42.169]                   args[[name]] <- ""
[17:29:42.169]                 }
[17:29:42.169]                 NAMES <- toupper(removed)
[17:29:42.169]                 for (kk in seq_along(NAMES)) {
[17:29:42.169]                   name <- removed[[kk]]
[17:29:42.169]                   NAME <- NAMES[[kk]]
[17:29:42.169]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.169]                     next
[17:29:42.169]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.169]                 }
[17:29:42.169]                 if (length(args) > 0) 
[17:29:42.169]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.169]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.169]             }
[17:29:42.169]             else {
[17:29:42.169]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.169]             }
[17:29:42.169]             {
[17:29:42.169]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.169]                   0L) {
[17:29:42.169]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.169]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.169]                   base::options(opts)
[17:29:42.169]                 }
[17:29:42.169]                 {
[17:29:42.169]                   {
[17:29:42.169]                     base::assign(".Random.seed", c(10407L, -440760210L, 
[17:29:42.169]                     1995121623L, 604992664L, -1294538296L, -2087679657L, 
[17:29:42.169]                     1574614759L), envir = base::globalenv(), 
[17:29:42.169]                       inherits = FALSE)
[17:29:42.169]                     NULL
[17:29:42.169]                   }
[17:29:42.169]                   options(future.plan = NULL)
[17:29:42.169]                   if (is.na(NA_character_)) 
[17:29:42.169]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.169]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.169]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.169]                     .init = FALSE)
[17:29:42.169]                 }
[17:29:42.169]             }
[17:29:42.169]         }
[17:29:42.169]     })
[17:29:42.169]     if (TRUE) {
[17:29:42.169]         base::sink(type = "output", split = FALSE)
[17:29:42.169]         if (TRUE) {
[17:29:42.169]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.169]         }
[17:29:42.169]         else {
[17:29:42.169]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.169]         }
[17:29:42.169]         base::close(...future.stdout)
[17:29:42.169]         ...future.stdout <- NULL
[17:29:42.169]     }
[17:29:42.169]     ...future.result$conditions <- ...future.conditions
[17:29:42.169]     ...future.result$finished <- base::Sys.time()
[17:29:42.169]     ...future.result
[17:29:42.169] }
[17:29:42.174] assign_globals() ...
[17:29:42.174] List of 1
[17:29:42.174]  $ x: int [1:4] 0 1 2 3
[17:29:42.174]  - attr(*, "where")=List of 1
[17:29:42.174]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.174]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.174]  - attr(*, "resolved")= logi FALSE
[17:29:42.174]  - attr(*, "total_size")= int 133
[17:29:42.174]  - attr(*, "already-done")= logi TRUE
[17:29:42.178] - copied 'x' to environment
[17:29:42.179] assign_globals() ... done
[17:29:42.179] plan(): Setting new future strategy stack:
[17:29:42.180] List of future strategies:
[17:29:42.180] 1. sequential:
[17:29:42.180]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.180]    - tweaked: FALSE
[17:29:42.180]    - call: NULL
[17:29:42.180] plan(): nbrOfWorkers() = 1
[17:29:42.182] plan(): Setting new future strategy stack:
[17:29:42.182] List of future strategies:
[17:29:42.182] 1. sequential:
[17:29:42.182]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.182]    - tweaked: FALSE
[17:29:42.182]    - call: plan(strategy)
[17:29:42.183] plan(): nbrOfWorkers() = 1
[17:29:42.183] SequentialFuture started (and completed)
[17:29:42.184] - Launch lazy future ... done
[17:29:42.184] run() for 'SequentialFuture' ... done
[17:29:42.185] getGlobalsAndPackages() ...
[17:29:42.185] Searching for globals...
[17:29:42.187] - globals found: [3] '{', 'sample', 'x'
[17:29:42.187] Searching for globals ... DONE
[17:29:42.187] Resolving globals: FALSE
[17:29:42.188] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.189] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.189] - globals: [1] 'x'
[17:29:42.189] 
[17:29:42.190] getGlobalsAndPackages() ... DONE
[17:29:42.190] run() for 'Future' ...
[17:29:42.190] - state: 'created'
[17:29:42.191] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.191] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.192] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.192]   - Field: 'label'
[17:29:42.192]   - Field: 'local'
[17:29:42.193]   - Field: 'owner'
[17:29:42.193]   - Field: 'envir'
[17:29:42.193]   - Field: 'packages'
[17:29:42.193]   - Field: 'gc'
[17:29:42.197]   - Field: 'conditions'
[17:29:42.197]   - Field: 'expr'
[17:29:42.198]   - Field: 'uuid'
[17:29:42.198]   - Field: 'seed'
[17:29:42.198]   - Field: 'version'
[17:29:42.199]   - Field: 'result'
[17:29:42.199]   - Field: 'asynchronous'
[17:29:42.199]   - Field: 'calls'
[17:29:42.199]   - Field: 'globals'
[17:29:42.200]   - Field: 'stdout'
[17:29:42.200]   - Field: 'earlySignal'
[17:29:42.200]   - Field: 'lazy'
[17:29:42.201]   - Field: 'state'
[17:29:42.201] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.201] - Launch lazy future ...
[17:29:42.202] Packages needed by the future expression (n = 0): <none>
[17:29:42.202] Packages needed by future strategies (n = 0): <none>
[17:29:42.203] {
[17:29:42.203]     {
[17:29:42.203]         {
[17:29:42.203]             ...future.startTime <- base::Sys.time()
[17:29:42.203]             {
[17:29:42.203]                 {
[17:29:42.203]                   {
[17:29:42.203]                     base::local({
[17:29:42.203]                       has_future <- base::requireNamespace("future", 
[17:29:42.203]                         quietly = TRUE)
[17:29:42.203]                       if (has_future) {
[17:29:42.203]                         ns <- base::getNamespace("future")
[17:29:42.203]                         version <- ns[[".package"]][["version"]]
[17:29:42.203]                         if (is.null(version)) 
[17:29:42.203]                           version <- utils::packageVersion("future")
[17:29:42.203]                       }
[17:29:42.203]                       else {
[17:29:42.203]                         version <- NULL
[17:29:42.203]                       }
[17:29:42.203]                       if (!has_future || version < "1.8.0") {
[17:29:42.203]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.203]                           "", base::R.version$version.string), 
[17:29:42.203]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.203]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.203]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.203]                             "release", "version")], collapse = " "), 
[17:29:42.203]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.203]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.203]                           info)
[17:29:42.203]                         info <- base::paste(info, collapse = "; ")
[17:29:42.203]                         if (!has_future) {
[17:29:42.203]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.203]                             info)
[17:29:42.203]                         }
[17:29:42.203]                         else {
[17:29:42.203]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.203]                             info, version)
[17:29:42.203]                         }
[17:29:42.203]                         base::stop(msg)
[17:29:42.203]                       }
[17:29:42.203]                     })
[17:29:42.203]                   }
[17:29:42.203]                   ...future.strategy.old <- future::plan("list")
[17:29:42.203]                   options(future.plan = NULL)
[17:29:42.203]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.203]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.203]                 }
[17:29:42.203]                 ...future.workdir <- getwd()
[17:29:42.203]             }
[17:29:42.203]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.203]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.203]         }
[17:29:42.203]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.203]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.203]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.203]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.203]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.203]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.203]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.203]             base::names(...future.oldOptions))
[17:29:42.203]     }
[17:29:42.203]     if (FALSE) {
[17:29:42.203]     }
[17:29:42.203]     else {
[17:29:42.203]         if (TRUE) {
[17:29:42.203]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.203]                 open = "w")
[17:29:42.203]         }
[17:29:42.203]         else {
[17:29:42.203]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.203]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.203]         }
[17:29:42.203]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.203]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.203]             base::sink(type = "output", split = FALSE)
[17:29:42.203]             base::close(...future.stdout)
[17:29:42.203]         }, add = TRUE)
[17:29:42.203]     }
[17:29:42.203]     ...future.frame <- base::sys.nframe()
[17:29:42.203]     ...future.conditions <- base::list()
[17:29:42.203]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.203]     if (FALSE) {
[17:29:42.203]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.203]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.203]     }
[17:29:42.203]     ...future.result <- base::tryCatch({
[17:29:42.203]         base::withCallingHandlers({
[17:29:42.203]             ...future.value <- base::withVisible(base::local({
[17:29:42.203]                 sample(x, size = 1L)
[17:29:42.203]             }))
[17:29:42.203]             future::FutureResult(value = ...future.value$value, 
[17:29:42.203]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.203]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.203]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.203]                     ...future.globalenv.names))
[17:29:42.203]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.203]         }, condition = base::local({
[17:29:42.203]             c <- base::c
[17:29:42.203]             inherits <- base::inherits
[17:29:42.203]             invokeRestart <- base::invokeRestart
[17:29:42.203]             length <- base::length
[17:29:42.203]             list <- base::list
[17:29:42.203]             seq.int <- base::seq.int
[17:29:42.203]             signalCondition <- base::signalCondition
[17:29:42.203]             sys.calls <- base::sys.calls
[17:29:42.203]             `[[` <- base::`[[`
[17:29:42.203]             `+` <- base::`+`
[17:29:42.203]             `<<-` <- base::`<<-`
[17:29:42.203]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.203]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.203]                   3L)]
[17:29:42.203]             }
[17:29:42.203]             function(cond) {
[17:29:42.203]                 is_error <- inherits(cond, "error")
[17:29:42.203]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.203]                   NULL)
[17:29:42.203]                 if (is_error) {
[17:29:42.203]                   sessionInformation <- function() {
[17:29:42.203]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.203]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.203]                       search = base::search(), system = base::Sys.info())
[17:29:42.203]                   }
[17:29:42.203]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.203]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.203]                     cond$call), session = sessionInformation(), 
[17:29:42.203]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.203]                   signalCondition(cond)
[17:29:42.203]                 }
[17:29:42.203]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.203]                 "immediateCondition"))) {
[17:29:42.203]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.203]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.203]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.203]                   if (TRUE && !signal) {
[17:29:42.203]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.203]                     {
[17:29:42.203]                       inherits <- base::inherits
[17:29:42.203]                       invokeRestart <- base::invokeRestart
[17:29:42.203]                       is.null <- base::is.null
[17:29:42.203]                       muffled <- FALSE
[17:29:42.203]                       if (inherits(cond, "message")) {
[17:29:42.203]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.203]                         if (muffled) 
[17:29:42.203]                           invokeRestart("muffleMessage")
[17:29:42.203]                       }
[17:29:42.203]                       else if (inherits(cond, "warning")) {
[17:29:42.203]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.203]                         if (muffled) 
[17:29:42.203]                           invokeRestart("muffleWarning")
[17:29:42.203]                       }
[17:29:42.203]                       else if (inherits(cond, "condition")) {
[17:29:42.203]                         if (!is.null(pattern)) {
[17:29:42.203]                           computeRestarts <- base::computeRestarts
[17:29:42.203]                           grepl <- base::grepl
[17:29:42.203]                           restarts <- computeRestarts(cond)
[17:29:42.203]                           for (restart in restarts) {
[17:29:42.203]                             name <- restart$name
[17:29:42.203]                             if (is.null(name)) 
[17:29:42.203]                               next
[17:29:42.203]                             if (!grepl(pattern, name)) 
[17:29:42.203]                               next
[17:29:42.203]                             invokeRestart(restart)
[17:29:42.203]                             muffled <- TRUE
[17:29:42.203]                             break
[17:29:42.203]                           }
[17:29:42.203]                         }
[17:29:42.203]                       }
[17:29:42.203]                       invisible(muffled)
[17:29:42.203]                     }
[17:29:42.203]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.203]                   }
[17:29:42.203]                 }
[17:29:42.203]                 else {
[17:29:42.203]                   if (TRUE) {
[17:29:42.203]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.203]                     {
[17:29:42.203]                       inherits <- base::inherits
[17:29:42.203]                       invokeRestart <- base::invokeRestart
[17:29:42.203]                       is.null <- base::is.null
[17:29:42.203]                       muffled <- FALSE
[17:29:42.203]                       if (inherits(cond, "message")) {
[17:29:42.203]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.203]                         if (muffled) 
[17:29:42.203]                           invokeRestart("muffleMessage")
[17:29:42.203]                       }
[17:29:42.203]                       else if (inherits(cond, "warning")) {
[17:29:42.203]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.203]                         if (muffled) 
[17:29:42.203]                           invokeRestart("muffleWarning")
[17:29:42.203]                       }
[17:29:42.203]                       else if (inherits(cond, "condition")) {
[17:29:42.203]                         if (!is.null(pattern)) {
[17:29:42.203]                           computeRestarts <- base::computeRestarts
[17:29:42.203]                           grepl <- base::grepl
[17:29:42.203]                           restarts <- computeRestarts(cond)
[17:29:42.203]                           for (restart in restarts) {
[17:29:42.203]                             name <- restart$name
[17:29:42.203]                             if (is.null(name)) 
[17:29:42.203]                               next
[17:29:42.203]                             if (!grepl(pattern, name)) 
[17:29:42.203]                               next
[17:29:42.203]                             invokeRestart(restart)
[17:29:42.203]                             muffled <- TRUE
[17:29:42.203]                             break
[17:29:42.203]                           }
[17:29:42.203]                         }
[17:29:42.203]                       }
[17:29:42.203]                       invisible(muffled)
[17:29:42.203]                     }
[17:29:42.203]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.203]                   }
[17:29:42.203]                 }
[17:29:42.203]             }
[17:29:42.203]         }))
[17:29:42.203]     }, error = function(ex) {
[17:29:42.203]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.203]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.203]                 ...future.rng), started = ...future.startTime, 
[17:29:42.203]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.203]             version = "1.8"), class = "FutureResult")
[17:29:42.203]     }, finally = {
[17:29:42.203]         if (!identical(...future.workdir, getwd())) 
[17:29:42.203]             setwd(...future.workdir)
[17:29:42.203]         {
[17:29:42.203]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.203]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.203]             }
[17:29:42.203]             base::options(...future.oldOptions)
[17:29:42.203]             if (.Platform$OS.type == "windows") {
[17:29:42.203]                 old_names <- names(...future.oldEnvVars)
[17:29:42.203]                 envs <- base::Sys.getenv()
[17:29:42.203]                 names <- names(envs)
[17:29:42.203]                 common <- intersect(names, old_names)
[17:29:42.203]                 added <- setdiff(names, old_names)
[17:29:42.203]                 removed <- setdiff(old_names, names)
[17:29:42.203]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.203]                   envs[common]]
[17:29:42.203]                 NAMES <- toupper(changed)
[17:29:42.203]                 args <- list()
[17:29:42.203]                 for (kk in seq_along(NAMES)) {
[17:29:42.203]                   name <- changed[[kk]]
[17:29:42.203]                   NAME <- NAMES[[kk]]
[17:29:42.203]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.203]                     next
[17:29:42.203]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.203]                 }
[17:29:42.203]                 NAMES <- toupper(added)
[17:29:42.203]                 for (kk in seq_along(NAMES)) {
[17:29:42.203]                   name <- added[[kk]]
[17:29:42.203]                   NAME <- NAMES[[kk]]
[17:29:42.203]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.203]                     next
[17:29:42.203]                   args[[name]] <- ""
[17:29:42.203]                 }
[17:29:42.203]                 NAMES <- toupper(removed)
[17:29:42.203]                 for (kk in seq_along(NAMES)) {
[17:29:42.203]                   name <- removed[[kk]]
[17:29:42.203]                   NAME <- NAMES[[kk]]
[17:29:42.203]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.203]                     next
[17:29:42.203]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.203]                 }
[17:29:42.203]                 if (length(args) > 0) 
[17:29:42.203]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.203]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.203]             }
[17:29:42.203]             else {
[17:29:42.203]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.203]             }
[17:29:42.203]             {
[17:29:42.203]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.203]                   0L) {
[17:29:42.203]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.203]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.203]                   base::options(opts)
[17:29:42.203]                 }
[17:29:42.203]                 {
[17:29:42.203]                   {
[17:29:42.203]                     base::assign(".Random.seed", c(10407L, 604992664L, 
[17:29:42.203]                     -1930727367L, -1517772855L, 1574614759L, 
[17:29:42.203]                     140996430L, 369472255L), envir = base::globalenv(), 
[17:29:42.203]                       inherits = FALSE)
[17:29:42.203]                     NULL
[17:29:42.203]                   }
[17:29:42.203]                   options(future.plan = NULL)
[17:29:42.203]                   if (is.na(NA_character_)) 
[17:29:42.203]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.203]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.203]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.203]                     .init = FALSE)
[17:29:42.203]                 }
[17:29:42.203]             }
[17:29:42.203]         }
[17:29:42.203]     })
[17:29:42.203]     if (TRUE) {
[17:29:42.203]         base::sink(type = "output", split = FALSE)
[17:29:42.203]         if (TRUE) {
[17:29:42.203]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.203]         }
[17:29:42.203]         else {
[17:29:42.203]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.203]         }
[17:29:42.203]         base::close(...future.stdout)
[17:29:42.203]         ...future.stdout <- NULL
[17:29:42.203]     }
[17:29:42.203]     ...future.result$conditions <- ...future.conditions
[17:29:42.203]     ...future.result$finished <- base::Sys.time()
[17:29:42.203]     ...future.result
[17:29:42.203] }
[17:29:42.209] assign_globals() ...
[17:29:42.209] List of 1
[17:29:42.209]  $ x: int [1:4] 0 1 2 3
[17:29:42.209]  - attr(*, "where")=List of 1
[17:29:42.209]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.209]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.209]  - attr(*, "resolved")= logi FALSE
[17:29:42.209]  - attr(*, "total_size")= int 133
[17:29:42.209]  - attr(*, "already-done")= logi TRUE
[17:29:42.214] - copied 'x' to environment
[17:29:42.214] assign_globals() ... done
[17:29:42.215] plan(): Setting new future strategy stack:
[17:29:42.215] List of future strategies:
[17:29:42.215] 1. sequential:
[17:29:42.215]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.215]    - tweaked: FALSE
[17:29:42.215]    - call: NULL
[17:29:42.216] plan(): nbrOfWorkers() = 1
[17:29:42.218] plan(): Setting new future strategy stack:
[17:29:42.218] List of future strategies:
[17:29:42.218] 1. sequential:
[17:29:42.218]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.218]    - tweaked: FALSE
[17:29:42.218]    - call: plan(strategy)
[17:29:42.219] plan(): nbrOfWorkers() = 1
[17:29:42.220] SequentialFuture started (and completed)
[17:29:42.220] - Launch lazy future ... done
[17:29:42.220] run() for 'SequentialFuture' ... done
[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 0

[[4]]
[1] 3

[17:29:42.222] getGlobalsAndPackages() ...
[17:29:42.223] Searching for globals...
[17:29:42.224] - globals found: [3] '{', 'sample', 'x'
[17:29:42.225] Searching for globals ... DONE
[17:29:42.225] Resolving globals: FALSE
[17:29:42.226] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.226] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.227] - globals: [1] 'x'
[17:29:42.227] 
[17:29:42.227] getGlobalsAndPackages() ... DONE
[17:29:42.228] run() for 'Future' ...
[17:29:42.228] - state: 'created'
[17:29:42.228] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.229] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.229] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.229]   - Field: 'label'
[17:29:42.230]   - Field: 'local'
[17:29:42.230]   - Field: 'owner'
[17:29:42.230]   - Field: 'envir'
[17:29:42.230]   - Field: 'packages'
[17:29:42.231]   - Field: 'gc'
[17:29:42.231]   - Field: 'conditions'
[17:29:42.231]   - Field: 'expr'
[17:29:42.231]   - Field: 'uuid'
[17:29:42.232]   - Field: 'seed'
[17:29:42.232]   - Field: 'version'
[17:29:42.232]   - Field: 'result'
[17:29:42.233]   - Field: 'asynchronous'
[17:29:42.233]   - Field: 'calls'
[17:29:42.233]   - Field: 'globals'
[17:29:42.233]   - Field: 'stdout'
[17:29:42.234]   - Field: 'earlySignal'
[17:29:42.234]   - Field: 'lazy'
[17:29:42.234]   - Field: 'state'
[17:29:42.234] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.235] - Launch lazy future ...
[17:29:42.235] Packages needed by the future expression (n = 0): <none>
[17:29:42.235] Packages needed by future strategies (n = 0): <none>
[17:29:42.236] {
[17:29:42.236]     {
[17:29:42.236]         {
[17:29:42.236]             ...future.startTime <- base::Sys.time()
[17:29:42.236]             {
[17:29:42.236]                 {
[17:29:42.236]                   {
[17:29:42.236]                     base::local({
[17:29:42.236]                       has_future <- base::requireNamespace("future", 
[17:29:42.236]                         quietly = TRUE)
[17:29:42.236]                       if (has_future) {
[17:29:42.236]                         ns <- base::getNamespace("future")
[17:29:42.236]                         version <- ns[[".package"]][["version"]]
[17:29:42.236]                         if (is.null(version)) 
[17:29:42.236]                           version <- utils::packageVersion("future")
[17:29:42.236]                       }
[17:29:42.236]                       else {
[17:29:42.236]                         version <- NULL
[17:29:42.236]                       }
[17:29:42.236]                       if (!has_future || version < "1.8.0") {
[17:29:42.236]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.236]                           "", base::R.version$version.string), 
[17:29:42.236]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.236]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.236]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.236]                             "release", "version")], collapse = " "), 
[17:29:42.236]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.236]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.236]                           info)
[17:29:42.236]                         info <- base::paste(info, collapse = "; ")
[17:29:42.236]                         if (!has_future) {
[17:29:42.236]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.236]                             info)
[17:29:42.236]                         }
[17:29:42.236]                         else {
[17:29:42.236]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.236]                             info, version)
[17:29:42.236]                         }
[17:29:42.236]                         base::stop(msg)
[17:29:42.236]                       }
[17:29:42.236]                     })
[17:29:42.236]                   }
[17:29:42.236]                   ...future.strategy.old <- future::plan("list")
[17:29:42.236]                   options(future.plan = NULL)
[17:29:42.236]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.236]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.236]                 }
[17:29:42.236]                 ...future.workdir <- getwd()
[17:29:42.236]             }
[17:29:42.236]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.236]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.236]         }
[17:29:42.236]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.236]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.236]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.236]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.236]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.236]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.236]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.236]             base::names(...future.oldOptions))
[17:29:42.236]     }
[17:29:42.236]     if (FALSE) {
[17:29:42.236]     }
[17:29:42.236]     else {
[17:29:42.236]         if (TRUE) {
[17:29:42.236]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.236]                 open = "w")
[17:29:42.236]         }
[17:29:42.236]         else {
[17:29:42.236]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.236]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.236]         }
[17:29:42.236]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.236]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.236]             base::sink(type = "output", split = FALSE)
[17:29:42.236]             base::close(...future.stdout)
[17:29:42.236]         }, add = TRUE)
[17:29:42.236]     }
[17:29:42.236]     ...future.frame <- base::sys.nframe()
[17:29:42.236]     ...future.conditions <- base::list()
[17:29:42.236]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.236]     if (FALSE) {
[17:29:42.236]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.236]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.236]     }
[17:29:42.236]     ...future.result <- base::tryCatch({
[17:29:42.236]         base::withCallingHandlers({
[17:29:42.236]             ...future.value <- base::withVisible(base::local({
[17:29:42.236]                 sample(x, size = 1L)
[17:29:42.236]             }))
[17:29:42.236]             future::FutureResult(value = ...future.value$value, 
[17:29:42.236]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.236]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.236]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.236]                     ...future.globalenv.names))
[17:29:42.236]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.236]         }, condition = base::local({
[17:29:42.236]             c <- base::c
[17:29:42.236]             inherits <- base::inherits
[17:29:42.236]             invokeRestart <- base::invokeRestart
[17:29:42.236]             length <- base::length
[17:29:42.236]             list <- base::list
[17:29:42.236]             seq.int <- base::seq.int
[17:29:42.236]             signalCondition <- base::signalCondition
[17:29:42.236]             sys.calls <- base::sys.calls
[17:29:42.236]             `[[` <- base::`[[`
[17:29:42.236]             `+` <- base::`+`
[17:29:42.236]             `<<-` <- base::`<<-`
[17:29:42.236]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.236]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.236]                   3L)]
[17:29:42.236]             }
[17:29:42.236]             function(cond) {
[17:29:42.236]                 is_error <- inherits(cond, "error")
[17:29:42.236]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.236]                   NULL)
[17:29:42.236]                 if (is_error) {
[17:29:42.236]                   sessionInformation <- function() {
[17:29:42.236]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.236]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.236]                       search = base::search(), system = base::Sys.info())
[17:29:42.236]                   }
[17:29:42.236]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.236]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.236]                     cond$call), session = sessionInformation(), 
[17:29:42.236]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.236]                   signalCondition(cond)
[17:29:42.236]                 }
[17:29:42.236]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.236]                 "immediateCondition"))) {
[17:29:42.236]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.236]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.236]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.236]                   if (TRUE && !signal) {
[17:29:42.236]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.236]                     {
[17:29:42.236]                       inherits <- base::inherits
[17:29:42.236]                       invokeRestart <- base::invokeRestart
[17:29:42.236]                       is.null <- base::is.null
[17:29:42.236]                       muffled <- FALSE
[17:29:42.236]                       if (inherits(cond, "message")) {
[17:29:42.236]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.236]                         if (muffled) 
[17:29:42.236]                           invokeRestart("muffleMessage")
[17:29:42.236]                       }
[17:29:42.236]                       else if (inherits(cond, "warning")) {
[17:29:42.236]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.236]                         if (muffled) 
[17:29:42.236]                           invokeRestart("muffleWarning")
[17:29:42.236]                       }
[17:29:42.236]                       else if (inherits(cond, "condition")) {
[17:29:42.236]                         if (!is.null(pattern)) {
[17:29:42.236]                           computeRestarts <- base::computeRestarts
[17:29:42.236]                           grepl <- base::grepl
[17:29:42.236]                           restarts <- computeRestarts(cond)
[17:29:42.236]                           for (restart in restarts) {
[17:29:42.236]                             name <- restart$name
[17:29:42.236]                             if (is.null(name)) 
[17:29:42.236]                               next
[17:29:42.236]                             if (!grepl(pattern, name)) 
[17:29:42.236]                               next
[17:29:42.236]                             invokeRestart(restart)
[17:29:42.236]                             muffled <- TRUE
[17:29:42.236]                             break
[17:29:42.236]                           }
[17:29:42.236]                         }
[17:29:42.236]                       }
[17:29:42.236]                       invisible(muffled)
[17:29:42.236]                     }
[17:29:42.236]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.236]                   }
[17:29:42.236]                 }
[17:29:42.236]                 else {
[17:29:42.236]                   if (TRUE) {
[17:29:42.236]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.236]                     {
[17:29:42.236]                       inherits <- base::inherits
[17:29:42.236]                       invokeRestart <- base::invokeRestart
[17:29:42.236]                       is.null <- base::is.null
[17:29:42.236]                       muffled <- FALSE
[17:29:42.236]                       if (inherits(cond, "message")) {
[17:29:42.236]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.236]                         if (muffled) 
[17:29:42.236]                           invokeRestart("muffleMessage")
[17:29:42.236]                       }
[17:29:42.236]                       else if (inherits(cond, "warning")) {
[17:29:42.236]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.236]                         if (muffled) 
[17:29:42.236]                           invokeRestart("muffleWarning")
[17:29:42.236]                       }
[17:29:42.236]                       else if (inherits(cond, "condition")) {
[17:29:42.236]                         if (!is.null(pattern)) {
[17:29:42.236]                           computeRestarts <- base::computeRestarts
[17:29:42.236]                           grepl <- base::grepl
[17:29:42.236]                           restarts <- computeRestarts(cond)
[17:29:42.236]                           for (restart in restarts) {
[17:29:42.236]                             name <- restart$name
[17:29:42.236]                             if (is.null(name)) 
[17:29:42.236]                               next
[17:29:42.236]                             if (!grepl(pattern, name)) 
[17:29:42.236]                               next
[17:29:42.236]                             invokeRestart(restart)
[17:29:42.236]                             muffled <- TRUE
[17:29:42.236]                             break
[17:29:42.236]                           }
[17:29:42.236]                         }
[17:29:42.236]                       }
[17:29:42.236]                       invisible(muffled)
[17:29:42.236]                     }
[17:29:42.236]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.236]                   }
[17:29:42.236]                 }
[17:29:42.236]             }
[17:29:42.236]         }))
[17:29:42.236]     }, error = function(ex) {
[17:29:42.236]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.236]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.236]                 ...future.rng), started = ...future.startTime, 
[17:29:42.236]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.236]             version = "1.8"), class = "FutureResult")
[17:29:42.236]     }, finally = {
[17:29:42.236]         if (!identical(...future.workdir, getwd())) 
[17:29:42.236]             setwd(...future.workdir)
[17:29:42.236]         {
[17:29:42.236]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.236]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.236]             }
[17:29:42.236]             base::options(...future.oldOptions)
[17:29:42.236]             if (.Platform$OS.type == "windows") {
[17:29:42.236]                 old_names <- names(...future.oldEnvVars)
[17:29:42.236]                 envs <- base::Sys.getenv()
[17:29:42.236]                 names <- names(envs)
[17:29:42.236]                 common <- intersect(names, old_names)
[17:29:42.236]                 added <- setdiff(names, old_names)
[17:29:42.236]                 removed <- setdiff(old_names, names)
[17:29:42.236]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.236]                   envs[common]]
[17:29:42.236]                 NAMES <- toupper(changed)
[17:29:42.236]                 args <- list()
[17:29:42.236]                 for (kk in seq_along(NAMES)) {
[17:29:42.236]                   name <- changed[[kk]]
[17:29:42.236]                   NAME <- NAMES[[kk]]
[17:29:42.236]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.236]                     next
[17:29:42.236]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.236]                 }
[17:29:42.236]                 NAMES <- toupper(added)
[17:29:42.236]                 for (kk in seq_along(NAMES)) {
[17:29:42.236]                   name <- added[[kk]]
[17:29:42.236]                   NAME <- NAMES[[kk]]
[17:29:42.236]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.236]                     next
[17:29:42.236]                   args[[name]] <- ""
[17:29:42.236]                 }
[17:29:42.236]                 NAMES <- toupper(removed)
[17:29:42.236]                 for (kk in seq_along(NAMES)) {
[17:29:42.236]                   name <- removed[[kk]]
[17:29:42.236]                   NAME <- NAMES[[kk]]
[17:29:42.236]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.236]                     next
[17:29:42.236]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.236]                 }
[17:29:42.236]                 if (length(args) > 0) 
[17:29:42.236]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.236]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.236]             }
[17:29:42.236]             else {
[17:29:42.236]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.236]             }
[17:29:42.236]             {
[17:29:42.236]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.236]                   0L) {
[17:29:42.236]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.236]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.236]                   base::options(opts)
[17:29:42.236]                 }
[17:29:42.236]                 {
[17:29:42.236]                   {
[17:29:42.236]                     base::assign(".Random.seed", c(10407L, -154415262L, 
[17:29:42.236]                     461427532L, -1907126193L, 344757889L, 1497903237L, 
[17:29:42.236]                     226026504L), envir = base::globalenv(), inherits = FALSE)
[17:29:42.236]                     NULL
[17:29:42.236]                   }
[17:29:42.236]                   options(future.plan = NULL)
[17:29:42.236]                   if (is.na(NA_character_)) 
[17:29:42.236]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.236]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.236]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.236]                     .init = FALSE)
[17:29:42.236]                 }
[17:29:42.236]             }
[17:29:42.236]         }
[17:29:42.236]     })
[17:29:42.236]     if (TRUE) {
[17:29:42.236]         base::sink(type = "output", split = FALSE)
[17:29:42.236]         if (TRUE) {
[17:29:42.236]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.236]         }
[17:29:42.236]         else {
[17:29:42.236]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.236]         }
[17:29:42.236]         base::close(...future.stdout)
[17:29:42.236]         ...future.stdout <- NULL
[17:29:42.236]     }
[17:29:42.236]     ...future.result$conditions <- ...future.conditions
[17:29:42.236]     ...future.result$finished <- base::Sys.time()
[17:29:42.236]     ...future.result
[17:29:42.236] }
[17:29:42.242] assign_globals() ...
[17:29:42.242] List of 1
[17:29:42.242]  $ x: int [1:4] 0 1 2 3
[17:29:42.242]  - attr(*, "where")=List of 1
[17:29:42.242]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.242]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.242]  - attr(*, "resolved")= logi FALSE
[17:29:42.242]  - attr(*, "total_size")= int 133
[17:29:42.242]  - attr(*, "already-done")= logi TRUE
[17:29:42.250] - copied 'x' to environment
[17:29:42.250] assign_globals() ... done
[17:29:42.250] plan(): Setting new future strategy stack:
[17:29:42.251] List of future strategies:
[17:29:42.251] 1. sequential:
[17:29:42.251]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.251]    - tweaked: FALSE
[17:29:42.251]    - call: NULL
[17:29:42.252] plan(): nbrOfWorkers() = 1
[17:29:42.254] plan(): Setting new future strategy stack:
[17:29:42.254] List of future strategies:
[17:29:42.254] 1. sequential:
[17:29:42.254]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.254]    - tweaked: FALSE
[17:29:42.254]    - call: plan(strategy)
[17:29:42.255] plan(): nbrOfWorkers() = 1
[17:29:42.255] SequentialFuture started (and completed)
[17:29:42.255] - Launch lazy future ... done
[17:29:42.256] run() for 'SequentialFuture' ... done
[17:29:42.257] getGlobalsAndPackages() ...
[17:29:42.257] Searching for globals...
[17:29:42.259] - globals found: [3] '{', 'sample', 'x'
[17:29:42.259] Searching for globals ... DONE
[17:29:42.259] Resolving globals: FALSE
[17:29:42.260] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.261] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.261] - globals: [1] 'x'
[17:29:42.261] 
[17:29:42.261] getGlobalsAndPackages() ... DONE
[17:29:42.262] run() for 'Future' ...
[17:29:42.262] - state: 'created'
[17:29:42.262] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.263] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.263] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.263]   - Field: 'label'
[17:29:42.264]   - Field: 'local'
[17:29:42.264]   - Field: 'owner'
[17:29:42.264]   - Field: 'envir'
[17:29:42.265]   - Field: 'packages'
[17:29:42.265]   - Field: 'gc'
[17:29:42.265]   - Field: 'conditions'
[17:29:42.265]   - Field: 'expr'
[17:29:42.266]   - Field: 'uuid'
[17:29:42.266]   - Field: 'seed'
[17:29:42.266]   - Field: 'version'
[17:29:42.266]   - Field: 'result'
[17:29:42.267]   - Field: 'asynchronous'
[17:29:42.267]   - Field: 'calls'
[17:29:42.267]   - Field: 'globals'
[17:29:42.267]   - Field: 'stdout'
[17:29:42.268]   - Field: 'earlySignal'
[17:29:42.268]   - Field: 'lazy'
[17:29:42.268]   - Field: 'state'
[17:29:42.268] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.269] - Launch lazy future ...
[17:29:42.269] Packages needed by the future expression (n = 0): <none>
[17:29:42.269] Packages needed by future strategies (n = 0): <none>
[17:29:42.270] {
[17:29:42.270]     {
[17:29:42.270]         {
[17:29:42.270]             ...future.startTime <- base::Sys.time()
[17:29:42.270]             {
[17:29:42.270]                 {
[17:29:42.270]                   {
[17:29:42.270]                     base::local({
[17:29:42.270]                       has_future <- base::requireNamespace("future", 
[17:29:42.270]                         quietly = TRUE)
[17:29:42.270]                       if (has_future) {
[17:29:42.270]                         ns <- base::getNamespace("future")
[17:29:42.270]                         version <- ns[[".package"]][["version"]]
[17:29:42.270]                         if (is.null(version)) 
[17:29:42.270]                           version <- utils::packageVersion("future")
[17:29:42.270]                       }
[17:29:42.270]                       else {
[17:29:42.270]                         version <- NULL
[17:29:42.270]                       }
[17:29:42.270]                       if (!has_future || version < "1.8.0") {
[17:29:42.270]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.270]                           "", base::R.version$version.string), 
[17:29:42.270]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.270]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.270]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.270]                             "release", "version")], collapse = " "), 
[17:29:42.270]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.270]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.270]                           info)
[17:29:42.270]                         info <- base::paste(info, collapse = "; ")
[17:29:42.270]                         if (!has_future) {
[17:29:42.270]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.270]                             info)
[17:29:42.270]                         }
[17:29:42.270]                         else {
[17:29:42.270]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.270]                             info, version)
[17:29:42.270]                         }
[17:29:42.270]                         base::stop(msg)
[17:29:42.270]                       }
[17:29:42.270]                     })
[17:29:42.270]                   }
[17:29:42.270]                   ...future.strategy.old <- future::plan("list")
[17:29:42.270]                   options(future.plan = NULL)
[17:29:42.270]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.270]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.270]                 }
[17:29:42.270]                 ...future.workdir <- getwd()
[17:29:42.270]             }
[17:29:42.270]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.270]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.270]         }
[17:29:42.270]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.270]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.270]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.270]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.270]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.270]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.270]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.270]             base::names(...future.oldOptions))
[17:29:42.270]     }
[17:29:42.270]     if (FALSE) {
[17:29:42.270]     }
[17:29:42.270]     else {
[17:29:42.270]         if (TRUE) {
[17:29:42.270]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.270]                 open = "w")
[17:29:42.270]         }
[17:29:42.270]         else {
[17:29:42.270]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.270]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.270]         }
[17:29:42.270]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.270]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.270]             base::sink(type = "output", split = FALSE)
[17:29:42.270]             base::close(...future.stdout)
[17:29:42.270]         }, add = TRUE)
[17:29:42.270]     }
[17:29:42.270]     ...future.frame <- base::sys.nframe()
[17:29:42.270]     ...future.conditions <- base::list()
[17:29:42.270]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.270]     if (FALSE) {
[17:29:42.270]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.270]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.270]     }
[17:29:42.270]     ...future.result <- base::tryCatch({
[17:29:42.270]         base::withCallingHandlers({
[17:29:42.270]             ...future.value <- base::withVisible(base::local({
[17:29:42.270]                 sample(x, size = 1L)
[17:29:42.270]             }))
[17:29:42.270]             future::FutureResult(value = ...future.value$value, 
[17:29:42.270]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.270]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.270]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.270]                     ...future.globalenv.names))
[17:29:42.270]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.270]         }, condition = base::local({
[17:29:42.270]             c <- base::c
[17:29:42.270]             inherits <- base::inherits
[17:29:42.270]             invokeRestart <- base::invokeRestart
[17:29:42.270]             length <- base::length
[17:29:42.270]             list <- base::list
[17:29:42.270]             seq.int <- base::seq.int
[17:29:42.270]             signalCondition <- base::signalCondition
[17:29:42.270]             sys.calls <- base::sys.calls
[17:29:42.270]             `[[` <- base::`[[`
[17:29:42.270]             `+` <- base::`+`
[17:29:42.270]             `<<-` <- base::`<<-`
[17:29:42.270]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.270]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.270]                   3L)]
[17:29:42.270]             }
[17:29:42.270]             function(cond) {
[17:29:42.270]                 is_error <- inherits(cond, "error")
[17:29:42.270]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.270]                   NULL)
[17:29:42.270]                 if (is_error) {
[17:29:42.270]                   sessionInformation <- function() {
[17:29:42.270]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.270]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.270]                       search = base::search(), system = base::Sys.info())
[17:29:42.270]                   }
[17:29:42.270]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.270]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.270]                     cond$call), session = sessionInformation(), 
[17:29:42.270]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.270]                   signalCondition(cond)
[17:29:42.270]                 }
[17:29:42.270]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.270]                 "immediateCondition"))) {
[17:29:42.270]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.270]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.270]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.270]                   if (TRUE && !signal) {
[17:29:42.270]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.270]                     {
[17:29:42.270]                       inherits <- base::inherits
[17:29:42.270]                       invokeRestart <- base::invokeRestart
[17:29:42.270]                       is.null <- base::is.null
[17:29:42.270]                       muffled <- FALSE
[17:29:42.270]                       if (inherits(cond, "message")) {
[17:29:42.270]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.270]                         if (muffled) 
[17:29:42.270]                           invokeRestart("muffleMessage")
[17:29:42.270]                       }
[17:29:42.270]                       else if (inherits(cond, "warning")) {
[17:29:42.270]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.270]                         if (muffled) 
[17:29:42.270]                           invokeRestart("muffleWarning")
[17:29:42.270]                       }
[17:29:42.270]                       else if (inherits(cond, "condition")) {
[17:29:42.270]                         if (!is.null(pattern)) {
[17:29:42.270]                           computeRestarts <- base::computeRestarts
[17:29:42.270]                           grepl <- base::grepl
[17:29:42.270]                           restarts <- computeRestarts(cond)
[17:29:42.270]                           for (restart in restarts) {
[17:29:42.270]                             name <- restart$name
[17:29:42.270]                             if (is.null(name)) 
[17:29:42.270]                               next
[17:29:42.270]                             if (!grepl(pattern, name)) 
[17:29:42.270]                               next
[17:29:42.270]                             invokeRestart(restart)
[17:29:42.270]                             muffled <- TRUE
[17:29:42.270]                             break
[17:29:42.270]                           }
[17:29:42.270]                         }
[17:29:42.270]                       }
[17:29:42.270]                       invisible(muffled)
[17:29:42.270]                     }
[17:29:42.270]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.270]                   }
[17:29:42.270]                 }
[17:29:42.270]                 else {
[17:29:42.270]                   if (TRUE) {
[17:29:42.270]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.270]                     {
[17:29:42.270]                       inherits <- base::inherits
[17:29:42.270]                       invokeRestart <- base::invokeRestart
[17:29:42.270]                       is.null <- base::is.null
[17:29:42.270]                       muffled <- FALSE
[17:29:42.270]                       if (inherits(cond, "message")) {
[17:29:42.270]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.270]                         if (muffled) 
[17:29:42.270]                           invokeRestart("muffleMessage")
[17:29:42.270]                       }
[17:29:42.270]                       else if (inherits(cond, "warning")) {
[17:29:42.270]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.270]                         if (muffled) 
[17:29:42.270]                           invokeRestart("muffleWarning")
[17:29:42.270]                       }
[17:29:42.270]                       else if (inherits(cond, "condition")) {
[17:29:42.270]                         if (!is.null(pattern)) {
[17:29:42.270]                           computeRestarts <- base::computeRestarts
[17:29:42.270]                           grepl <- base::grepl
[17:29:42.270]                           restarts <- computeRestarts(cond)
[17:29:42.270]                           for (restart in restarts) {
[17:29:42.270]                             name <- restart$name
[17:29:42.270]                             if (is.null(name)) 
[17:29:42.270]                               next
[17:29:42.270]                             if (!grepl(pattern, name)) 
[17:29:42.270]                               next
[17:29:42.270]                             invokeRestart(restart)
[17:29:42.270]                             muffled <- TRUE
[17:29:42.270]                             break
[17:29:42.270]                           }
[17:29:42.270]                         }
[17:29:42.270]                       }
[17:29:42.270]                       invisible(muffled)
[17:29:42.270]                     }
[17:29:42.270]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.270]                   }
[17:29:42.270]                 }
[17:29:42.270]             }
[17:29:42.270]         }))
[17:29:42.270]     }, error = function(ex) {
[17:29:42.270]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.270]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.270]                 ...future.rng), started = ...future.startTime, 
[17:29:42.270]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.270]             version = "1.8"), class = "FutureResult")
[17:29:42.270]     }, finally = {
[17:29:42.270]         if (!identical(...future.workdir, getwd())) 
[17:29:42.270]             setwd(...future.workdir)
[17:29:42.270]         {
[17:29:42.270]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.270]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.270]             }
[17:29:42.270]             base::options(...future.oldOptions)
[17:29:42.270]             if (.Platform$OS.type == "windows") {
[17:29:42.270]                 old_names <- names(...future.oldEnvVars)
[17:29:42.270]                 envs <- base::Sys.getenv()
[17:29:42.270]                 names <- names(envs)
[17:29:42.270]                 common <- intersect(names, old_names)
[17:29:42.270]                 added <- setdiff(names, old_names)
[17:29:42.270]                 removed <- setdiff(old_names, names)
[17:29:42.270]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.270]                   envs[common]]
[17:29:42.270]                 NAMES <- toupper(changed)
[17:29:42.270]                 args <- list()
[17:29:42.270]                 for (kk in seq_along(NAMES)) {
[17:29:42.270]                   name <- changed[[kk]]
[17:29:42.270]                   NAME <- NAMES[[kk]]
[17:29:42.270]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.270]                     next
[17:29:42.270]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.270]                 }
[17:29:42.270]                 NAMES <- toupper(added)
[17:29:42.270]                 for (kk in seq_along(NAMES)) {
[17:29:42.270]                   name <- added[[kk]]
[17:29:42.270]                   NAME <- NAMES[[kk]]
[17:29:42.270]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.270]                     next
[17:29:42.270]                   args[[name]] <- ""
[17:29:42.270]                 }
[17:29:42.270]                 NAMES <- toupper(removed)
[17:29:42.270]                 for (kk in seq_along(NAMES)) {
[17:29:42.270]                   name <- removed[[kk]]
[17:29:42.270]                   NAME <- NAMES[[kk]]
[17:29:42.270]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.270]                     next
[17:29:42.270]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.270]                 }
[17:29:42.270]                 if (length(args) > 0) 
[17:29:42.270]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.270]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.270]             }
[17:29:42.270]             else {
[17:29:42.270]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.270]             }
[17:29:42.270]             {
[17:29:42.270]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.270]                   0L) {
[17:29:42.270]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.270]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.270]                   base::options(opts)
[17:29:42.270]                 }
[17:29:42.270]                 {
[17:29:42.270]                   {
[17:29:42.270]                     base::assign(".Random.seed", c(10407L, -1907126193L, 
[17:29:42.270]                     -1610148932L, -598272471L, 226026504L, 695827463L, 
[17:29:42.270]                     -1122933629L), envir = base::globalenv(), 
[17:29:42.270]                       inherits = FALSE)
[17:29:42.270]                     NULL
[17:29:42.270]                   }
[17:29:42.270]                   options(future.plan = NULL)
[17:29:42.270]                   if (is.na(NA_character_)) 
[17:29:42.270]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.270]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.270]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.270]                     .init = FALSE)
[17:29:42.270]                 }
[17:29:42.270]             }
[17:29:42.270]         }
[17:29:42.270]     })
[17:29:42.270]     if (TRUE) {
[17:29:42.270]         base::sink(type = "output", split = FALSE)
[17:29:42.270]         if (TRUE) {
[17:29:42.270]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.270]         }
[17:29:42.270]         else {
[17:29:42.270]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.270]         }
[17:29:42.270]         base::close(...future.stdout)
[17:29:42.270]         ...future.stdout <- NULL
[17:29:42.270]     }
[17:29:42.270]     ...future.result$conditions <- ...future.conditions
[17:29:42.270]     ...future.result$finished <- base::Sys.time()
[17:29:42.270]     ...future.result
[17:29:42.270] }
[17:29:42.276] assign_globals() ...
[17:29:42.276] List of 1
[17:29:42.276]  $ x: int [1:4] 0 1 2 3
[17:29:42.276]  - attr(*, "where")=List of 1
[17:29:42.276]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.276]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.276]  - attr(*, "resolved")= logi FALSE
[17:29:42.276]  - attr(*, "total_size")= int 133
[17:29:42.276]  - attr(*, "already-done")= logi TRUE
[17:29:42.280] - copied 'x' to environment
[17:29:42.281] assign_globals() ... done
[17:29:42.281] plan(): Setting new future strategy stack:
[17:29:42.281] List of future strategies:
[17:29:42.281] 1. sequential:
[17:29:42.281]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.281]    - tweaked: FALSE
[17:29:42.281]    - call: NULL
[17:29:42.282] plan(): nbrOfWorkers() = 1
[17:29:42.284] plan(): Setting new future strategy stack:
[17:29:42.284] List of future strategies:
[17:29:42.284] 1. sequential:
[17:29:42.284]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.284]    - tweaked: FALSE
[17:29:42.284]    - call: plan(strategy)
[17:29:42.285] plan(): nbrOfWorkers() = 1
[17:29:42.285] SequentialFuture started (and completed)
[17:29:42.286] - Launch lazy future ... done
[17:29:42.286] run() for 'SequentialFuture' ... done
[17:29:42.287] getGlobalsAndPackages() ...
[17:29:42.287] Searching for globals...
[17:29:42.289] - globals found: [3] '{', 'sample', 'x'
[17:29:42.289] Searching for globals ... DONE
[17:29:42.289] Resolving globals: FALSE
[17:29:42.290] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.294] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.294] - globals: [1] 'x'
[17:29:42.294] 
[17:29:42.294] getGlobalsAndPackages() ... DONE
[17:29:42.295] run() for 'Future' ...
[17:29:42.295] - state: 'created'
[17:29:42.296] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.296] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.297] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.297]   - Field: 'label'
[17:29:42.297]   - Field: 'local'
[17:29:42.297]   - Field: 'owner'
[17:29:42.298]   - Field: 'envir'
[17:29:42.298]   - Field: 'packages'
[17:29:42.298]   - Field: 'gc'
[17:29:42.299]   - Field: 'conditions'
[17:29:42.299]   - Field: 'expr'
[17:29:42.299]   - Field: 'uuid'
[17:29:42.299]   - Field: 'seed'
[17:29:42.300]   - Field: 'version'
[17:29:42.300]   - Field: 'result'
[17:29:42.300]   - Field: 'asynchronous'
[17:29:42.301]   - Field: 'calls'
[17:29:42.301]   - Field: 'globals'
[17:29:42.301]   - Field: 'stdout'
[17:29:42.301]   - Field: 'earlySignal'
[17:29:42.302]   - Field: 'lazy'
[17:29:42.302]   - Field: 'state'
[17:29:42.302] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.302] - Launch lazy future ...
[17:29:42.303] Packages needed by the future expression (n = 0): <none>
[17:29:42.303] Packages needed by future strategies (n = 0): <none>
[17:29:42.304] {
[17:29:42.304]     {
[17:29:42.304]         {
[17:29:42.304]             ...future.startTime <- base::Sys.time()
[17:29:42.304]             {
[17:29:42.304]                 {
[17:29:42.304]                   {
[17:29:42.304]                     base::local({
[17:29:42.304]                       has_future <- base::requireNamespace("future", 
[17:29:42.304]                         quietly = TRUE)
[17:29:42.304]                       if (has_future) {
[17:29:42.304]                         ns <- base::getNamespace("future")
[17:29:42.304]                         version <- ns[[".package"]][["version"]]
[17:29:42.304]                         if (is.null(version)) 
[17:29:42.304]                           version <- utils::packageVersion("future")
[17:29:42.304]                       }
[17:29:42.304]                       else {
[17:29:42.304]                         version <- NULL
[17:29:42.304]                       }
[17:29:42.304]                       if (!has_future || version < "1.8.0") {
[17:29:42.304]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.304]                           "", base::R.version$version.string), 
[17:29:42.304]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.304]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.304]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.304]                             "release", "version")], collapse = " "), 
[17:29:42.304]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.304]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.304]                           info)
[17:29:42.304]                         info <- base::paste(info, collapse = "; ")
[17:29:42.304]                         if (!has_future) {
[17:29:42.304]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.304]                             info)
[17:29:42.304]                         }
[17:29:42.304]                         else {
[17:29:42.304]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.304]                             info, version)
[17:29:42.304]                         }
[17:29:42.304]                         base::stop(msg)
[17:29:42.304]                       }
[17:29:42.304]                     })
[17:29:42.304]                   }
[17:29:42.304]                   ...future.strategy.old <- future::plan("list")
[17:29:42.304]                   options(future.plan = NULL)
[17:29:42.304]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.304]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.304]                 }
[17:29:42.304]                 ...future.workdir <- getwd()
[17:29:42.304]             }
[17:29:42.304]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.304]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.304]         }
[17:29:42.304]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.304]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.304]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.304]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.304]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.304]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.304]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.304]             base::names(...future.oldOptions))
[17:29:42.304]     }
[17:29:42.304]     if (FALSE) {
[17:29:42.304]     }
[17:29:42.304]     else {
[17:29:42.304]         if (TRUE) {
[17:29:42.304]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.304]                 open = "w")
[17:29:42.304]         }
[17:29:42.304]         else {
[17:29:42.304]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.304]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.304]         }
[17:29:42.304]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.304]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.304]             base::sink(type = "output", split = FALSE)
[17:29:42.304]             base::close(...future.stdout)
[17:29:42.304]         }, add = TRUE)
[17:29:42.304]     }
[17:29:42.304]     ...future.frame <- base::sys.nframe()
[17:29:42.304]     ...future.conditions <- base::list()
[17:29:42.304]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.304]     if (FALSE) {
[17:29:42.304]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.304]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.304]     }
[17:29:42.304]     ...future.result <- base::tryCatch({
[17:29:42.304]         base::withCallingHandlers({
[17:29:42.304]             ...future.value <- base::withVisible(base::local({
[17:29:42.304]                 sample(x, size = 1L)
[17:29:42.304]             }))
[17:29:42.304]             future::FutureResult(value = ...future.value$value, 
[17:29:42.304]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.304]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.304]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.304]                     ...future.globalenv.names))
[17:29:42.304]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.304]         }, condition = base::local({
[17:29:42.304]             c <- base::c
[17:29:42.304]             inherits <- base::inherits
[17:29:42.304]             invokeRestart <- base::invokeRestart
[17:29:42.304]             length <- base::length
[17:29:42.304]             list <- base::list
[17:29:42.304]             seq.int <- base::seq.int
[17:29:42.304]             signalCondition <- base::signalCondition
[17:29:42.304]             sys.calls <- base::sys.calls
[17:29:42.304]             `[[` <- base::`[[`
[17:29:42.304]             `+` <- base::`+`
[17:29:42.304]             `<<-` <- base::`<<-`
[17:29:42.304]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.304]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.304]                   3L)]
[17:29:42.304]             }
[17:29:42.304]             function(cond) {
[17:29:42.304]                 is_error <- inherits(cond, "error")
[17:29:42.304]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.304]                   NULL)
[17:29:42.304]                 if (is_error) {
[17:29:42.304]                   sessionInformation <- function() {
[17:29:42.304]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.304]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.304]                       search = base::search(), system = base::Sys.info())
[17:29:42.304]                   }
[17:29:42.304]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.304]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.304]                     cond$call), session = sessionInformation(), 
[17:29:42.304]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.304]                   signalCondition(cond)
[17:29:42.304]                 }
[17:29:42.304]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.304]                 "immediateCondition"))) {
[17:29:42.304]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.304]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.304]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.304]                   if (TRUE && !signal) {
[17:29:42.304]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.304]                     {
[17:29:42.304]                       inherits <- base::inherits
[17:29:42.304]                       invokeRestart <- base::invokeRestart
[17:29:42.304]                       is.null <- base::is.null
[17:29:42.304]                       muffled <- FALSE
[17:29:42.304]                       if (inherits(cond, "message")) {
[17:29:42.304]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.304]                         if (muffled) 
[17:29:42.304]                           invokeRestart("muffleMessage")
[17:29:42.304]                       }
[17:29:42.304]                       else if (inherits(cond, "warning")) {
[17:29:42.304]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.304]                         if (muffled) 
[17:29:42.304]                           invokeRestart("muffleWarning")
[17:29:42.304]                       }
[17:29:42.304]                       else if (inherits(cond, "condition")) {
[17:29:42.304]                         if (!is.null(pattern)) {
[17:29:42.304]                           computeRestarts <- base::computeRestarts
[17:29:42.304]                           grepl <- base::grepl
[17:29:42.304]                           restarts <- computeRestarts(cond)
[17:29:42.304]                           for (restart in restarts) {
[17:29:42.304]                             name <- restart$name
[17:29:42.304]                             if (is.null(name)) 
[17:29:42.304]                               next
[17:29:42.304]                             if (!grepl(pattern, name)) 
[17:29:42.304]                               next
[17:29:42.304]                             invokeRestart(restart)
[17:29:42.304]                             muffled <- TRUE
[17:29:42.304]                             break
[17:29:42.304]                           }
[17:29:42.304]                         }
[17:29:42.304]                       }
[17:29:42.304]                       invisible(muffled)
[17:29:42.304]                     }
[17:29:42.304]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.304]                   }
[17:29:42.304]                 }
[17:29:42.304]                 else {
[17:29:42.304]                   if (TRUE) {
[17:29:42.304]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.304]                     {
[17:29:42.304]                       inherits <- base::inherits
[17:29:42.304]                       invokeRestart <- base::invokeRestart
[17:29:42.304]                       is.null <- base::is.null
[17:29:42.304]                       muffled <- FALSE
[17:29:42.304]                       if (inherits(cond, "message")) {
[17:29:42.304]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.304]                         if (muffled) 
[17:29:42.304]                           invokeRestart("muffleMessage")
[17:29:42.304]                       }
[17:29:42.304]                       else if (inherits(cond, "warning")) {
[17:29:42.304]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.304]                         if (muffled) 
[17:29:42.304]                           invokeRestart("muffleWarning")
[17:29:42.304]                       }
[17:29:42.304]                       else if (inherits(cond, "condition")) {
[17:29:42.304]                         if (!is.null(pattern)) {
[17:29:42.304]                           computeRestarts <- base::computeRestarts
[17:29:42.304]                           grepl <- base::grepl
[17:29:42.304]                           restarts <- computeRestarts(cond)
[17:29:42.304]                           for (restart in restarts) {
[17:29:42.304]                             name <- restart$name
[17:29:42.304]                             if (is.null(name)) 
[17:29:42.304]                               next
[17:29:42.304]                             if (!grepl(pattern, name)) 
[17:29:42.304]                               next
[17:29:42.304]                             invokeRestart(restart)
[17:29:42.304]                             muffled <- TRUE
[17:29:42.304]                             break
[17:29:42.304]                           }
[17:29:42.304]                         }
[17:29:42.304]                       }
[17:29:42.304]                       invisible(muffled)
[17:29:42.304]                     }
[17:29:42.304]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.304]                   }
[17:29:42.304]                 }
[17:29:42.304]             }
[17:29:42.304]         }))
[17:29:42.304]     }, error = function(ex) {
[17:29:42.304]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.304]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.304]                 ...future.rng), started = ...future.startTime, 
[17:29:42.304]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.304]             version = "1.8"), class = "FutureResult")
[17:29:42.304]     }, finally = {
[17:29:42.304]         if (!identical(...future.workdir, getwd())) 
[17:29:42.304]             setwd(...future.workdir)
[17:29:42.304]         {
[17:29:42.304]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.304]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.304]             }
[17:29:42.304]             base::options(...future.oldOptions)
[17:29:42.304]             if (.Platform$OS.type == "windows") {
[17:29:42.304]                 old_names <- names(...future.oldEnvVars)
[17:29:42.304]                 envs <- base::Sys.getenv()
[17:29:42.304]                 names <- names(envs)
[17:29:42.304]                 common <- intersect(names, old_names)
[17:29:42.304]                 added <- setdiff(names, old_names)
[17:29:42.304]                 removed <- setdiff(old_names, names)
[17:29:42.304]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.304]                   envs[common]]
[17:29:42.304]                 NAMES <- toupper(changed)
[17:29:42.304]                 args <- list()
[17:29:42.304]                 for (kk in seq_along(NAMES)) {
[17:29:42.304]                   name <- changed[[kk]]
[17:29:42.304]                   NAME <- NAMES[[kk]]
[17:29:42.304]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.304]                     next
[17:29:42.304]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.304]                 }
[17:29:42.304]                 NAMES <- toupper(added)
[17:29:42.304]                 for (kk in seq_along(NAMES)) {
[17:29:42.304]                   name <- added[[kk]]
[17:29:42.304]                   NAME <- NAMES[[kk]]
[17:29:42.304]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.304]                     next
[17:29:42.304]                   args[[name]] <- ""
[17:29:42.304]                 }
[17:29:42.304]                 NAMES <- toupper(removed)
[17:29:42.304]                 for (kk in seq_along(NAMES)) {
[17:29:42.304]                   name <- removed[[kk]]
[17:29:42.304]                   NAME <- NAMES[[kk]]
[17:29:42.304]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.304]                     next
[17:29:42.304]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.304]                 }
[17:29:42.304]                 if (length(args) > 0) 
[17:29:42.304]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.304]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.304]             }
[17:29:42.304]             else {
[17:29:42.304]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.304]             }
[17:29:42.304]             {
[17:29:42.304]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.304]                   0L) {
[17:29:42.304]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.304]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.304]                   base::options(opts)
[17:29:42.304]                 }
[17:29:42.304]                 {
[17:29:42.304]                   {
[17:29:42.304]                     base::assign(".Random.seed", c(10407L, -598272471L, 
[17:29:42.304]                     -1464914058L, 750895670L, -1122933629L, 1223536571L, 
[17:29:42.304]                     -100347073L), envir = base::globalenv(), 
[17:29:42.304]                       inherits = FALSE)
[17:29:42.304]                     NULL
[17:29:42.304]                   }
[17:29:42.304]                   options(future.plan = NULL)
[17:29:42.304]                   if (is.na(NA_character_)) 
[17:29:42.304]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.304]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.304]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.304]                     .init = FALSE)
[17:29:42.304]                 }
[17:29:42.304]             }
[17:29:42.304]         }
[17:29:42.304]     })
[17:29:42.304]     if (TRUE) {
[17:29:42.304]         base::sink(type = "output", split = FALSE)
[17:29:42.304]         if (TRUE) {
[17:29:42.304]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.304]         }
[17:29:42.304]         else {
[17:29:42.304]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.304]         }
[17:29:42.304]         base::close(...future.stdout)
[17:29:42.304]         ...future.stdout <- NULL
[17:29:42.304]     }
[17:29:42.304]     ...future.result$conditions <- ...future.conditions
[17:29:42.304]     ...future.result$finished <- base::Sys.time()
[17:29:42.304]     ...future.result
[17:29:42.304] }
[17:29:42.309] assign_globals() ...
[17:29:42.310] List of 1
[17:29:42.310]  $ x: int [1:4] 0 1 2 3
[17:29:42.310]  - attr(*, "where")=List of 1
[17:29:42.310]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.310]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.310]  - attr(*, "resolved")= logi FALSE
[17:29:42.310]  - attr(*, "total_size")= int 133
[17:29:42.310]  - attr(*, "already-done")= logi TRUE
[17:29:42.314] - copied 'x' to environment
[17:29:42.314] assign_globals() ... done
[17:29:42.315] plan(): Setting new future strategy stack:
[17:29:42.315] List of future strategies:
[17:29:42.315] 1. sequential:
[17:29:42.315]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.315]    - tweaked: FALSE
[17:29:42.315]    - call: NULL
[17:29:42.316] plan(): nbrOfWorkers() = 1
[17:29:42.317] plan(): Setting new future strategy stack:
[17:29:42.318] List of future strategies:
[17:29:42.318] 1. sequential:
[17:29:42.318]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.318]    - tweaked: FALSE
[17:29:42.318]    - call: plan(strategy)
[17:29:42.318] plan(): nbrOfWorkers() = 1
[17:29:42.319] SequentialFuture started (and completed)
[17:29:42.319] - Launch lazy future ... done
[17:29:42.319] run() for 'SequentialFuture' ... done
[17:29:42.320] getGlobalsAndPackages() ...
[17:29:42.320] Searching for globals...
[17:29:42.322] - globals found: [3] '{', 'sample', 'x'
[17:29:42.322] Searching for globals ... DONE
[17:29:42.323] Resolving globals: FALSE
[17:29:42.323] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.324] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.324] - globals: [1] 'x'
[17:29:42.324] 
[17:29:42.324] getGlobalsAndPackages() ... DONE
[17:29:42.325] run() for 'Future' ...
[17:29:42.325] - state: 'created'
[17:29:42.326] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.326] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.326] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.327]   - Field: 'label'
[17:29:42.327]   - Field: 'local'
[17:29:42.327]   - Field: 'owner'
[17:29:42.327]   - Field: 'envir'
[17:29:42.328]   - Field: 'packages'
[17:29:42.328]   - Field: 'gc'
[17:29:42.328]   - Field: 'conditions'
[17:29:42.328]   - Field: 'expr'
[17:29:42.329]   - Field: 'uuid'
[17:29:42.329]   - Field: 'seed'
[17:29:42.329]   - Field: 'version'
[17:29:42.329]   - Field: 'result'
[17:29:42.330]   - Field: 'asynchronous'
[17:29:42.330]   - Field: 'calls'
[17:29:42.330]   - Field: 'globals'
[17:29:42.330]   - Field: 'stdout'
[17:29:42.331]   - Field: 'earlySignal'
[17:29:42.331]   - Field: 'lazy'
[17:29:42.331]   - Field: 'state'
[17:29:42.331] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.332] - Launch lazy future ...
[17:29:42.332] Packages needed by the future expression (n = 0): <none>
[17:29:42.332] Packages needed by future strategies (n = 0): <none>
[17:29:42.333] {
[17:29:42.333]     {
[17:29:42.333]         {
[17:29:42.333]             ...future.startTime <- base::Sys.time()
[17:29:42.333]             {
[17:29:42.333]                 {
[17:29:42.333]                   {
[17:29:42.333]                     base::local({
[17:29:42.333]                       has_future <- base::requireNamespace("future", 
[17:29:42.333]                         quietly = TRUE)
[17:29:42.333]                       if (has_future) {
[17:29:42.333]                         ns <- base::getNamespace("future")
[17:29:42.333]                         version <- ns[[".package"]][["version"]]
[17:29:42.333]                         if (is.null(version)) 
[17:29:42.333]                           version <- utils::packageVersion("future")
[17:29:42.333]                       }
[17:29:42.333]                       else {
[17:29:42.333]                         version <- NULL
[17:29:42.333]                       }
[17:29:42.333]                       if (!has_future || version < "1.8.0") {
[17:29:42.333]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.333]                           "", base::R.version$version.string), 
[17:29:42.333]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.333]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.333]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.333]                             "release", "version")], collapse = " "), 
[17:29:42.333]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.333]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.333]                           info)
[17:29:42.333]                         info <- base::paste(info, collapse = "; ")
[17:29:42.333]                         if (!has_future) {
[17:29:42.333]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.333]                             info)
[17:29:42.333]                         }
[17:29:42.333]                         else {
[17:29:42.333]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.333]                             info, version)
[17:29:42.333]                         }
[17:29:42.333]                         base::stop(msg)
[17:29:42.333]                       }
[17:29:42.333]                     })
[17:29:42.333]                   }
[17:29:42.333]                   ...future.strategy.old <- future::plan("list")
[17:29:42.333]                   options(future.plan = NULL)
[17:29:42.333]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.333]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.333]                 }
[17:29:42.333]                 ...future.workdir <- getwd()
[17:29:42.333]             }
[17:29:42.333]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.333]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.333]         }
[17:29:42.333]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.333]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.333]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.333]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.333]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.333]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.333]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.333]             base::names(...future.oldOptions))
[17:29:42.333]     }
[17:29:42.333]     if (FALSE) {
[17:29:42.333]     }
[17:29:42.333]     else {
[17:29:42.333]         if (TRUE) {
[17:29:42.333]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.333]                 open = "w")
[17:29:42.333]         }
[17:29:42.333]         else {
[17:29:42.333]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.333]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.333]         }
[17:29:42.333]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.333]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.333]             base::sink(type = "output", split = FALSE)
[17:29:42.333]             base::close(...future.stdout)
[17:29:42.333]         }, add = TRUE)
[17:29:42.333]     }
[17:29:42.333]     ...future.frame <- base::sys.nframe()
[17:29:42.333]     ...future.conditions <- base::list()
[17:29:42.333]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.333]     if (FALSE) {
[17:29:42.333]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.333]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.333]     }
[17:29:42.333]     ...future.result <- base::tryCatch({
[17:29:42.333]         base::withCallingHandlers({
[17:29:42.333]             ...future.value <- base::withVisible(base::local({
[17:29:42.333]                 sample(x, size = 1L)
[17:29:42.333]             }))
[17:29:42.333]             future::FutureResult(value = ...future.value$value, 
[17:29:42.333]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.333]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.333]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.333]                     ...future.globalenv.names))
[17:29:42.333]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.333]         }, condition = base::local({
[17:29:42.333]             c <- base::c
[17:29:42.333]             inherits <- base::inherits
[17:29:42.333]             invokeRestart <- base::invokeRestart
[17:29:42.333]             length <- base::length
[17:29:42.333]             list <- base::list
[17:29:42.333]             seq.int <- base::seq.int
[17:29:42.333]             signalCondition <- base::signalCondition
[17:29:42.333]             sys.calls <- base::sys.calls
[17:29:42.333]             `[[` <- base::`[[`
[17:29:42.333]             `+` <- base::`+`
[17:29:42.333]             `<<-` <- base::`<<-`
[17:29:42.333]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.333]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.333]                   3L)]
[17:29:42.333]             }
[17:29:42.333]             function(cond) {
[17:29:42.333]                 is_error <- inherits(cond, "error")
[17:29:42.333]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.333]                   NULL)
[17:29:42.333]                 if (is_error) {
[17:29:42.333]                   sessionInformation <- function() {
[17:29:42.333]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.333]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.333]                       search = base::search(), system = base::Sys.info())
[17:29:42.333]                   }
[17:29:42.333]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.333]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.333]                     cond$call), session = sessionInformation(), 
[17:29:42.333]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.333]                   signalCondition(cond)
[17:29:42.333]                 }
[17:29:42.333]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.333]                 "immediateCondition"))) {
[17:29:42.333]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.333]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.333]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.333]                   if (TRUE && !signal) {
[17:29:42.333]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.333]                     {
[17:29:42.333]                       inherits <- base::inherits
[17:29:42.333]                       invokeRestart <- base::invokeRestart
[17:29:42.333]                       is.null <- base::is.null
[17:29:42.333]                       muffled <- FALSE
[17:29:42.333]                       if (inherits(cond, "message")) {
[17:29:42.333]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.333]                         if (muffled) 
[17:29:42.333]                           invokeRestart("muffleMessage")
[17:29:42.333]                       }
[17:29:42.333]                       else if (inherits(cond, "warning")) {
[17:29:42.333]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.333]                         if (muffled) 
[17:29:42.333]                           invokeRestart("muffleWarning")
[17:29:42.333]                       }
[17:29:42.333]                       else if (inherits(cond, "condition")) {
[17:29:42.333]                         if (!is.null(pattern)) {
[17:29:42.333]                           computeRestarts <- base::computeRestarts
[17:29:42.333]                           grepl <- base::grepl
[17:29:42.333]                           restarts <- computeRestarts(cond)
[17:29:42.333]                           for (restart in restarts) {
[17:29:42.333]                             name <- restart$name
[17:29:42.333]                             if (is.null(name)) 
[17:29:42.333]                               next
[17:29:42.333]                             if (!grepl(pattern, name)) 
[17:29:42.333]                               next
[17:29:42.333]                             invokeRestart(restart)
[17:29:42.333]                             muffled <- TRUE
[17:29:42.333]                             break
[17:29:42.333]                           }
[17:29:42.333]                         }
[17:29:42.333]                       }
[17:29:42.333]                       invisible(muffled)
[17:29:42.333]                     }
[17:29:42.333]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.333]                   }
[17:29:42.333]                 }
[17:29:42.333]                 else {
[17:29:42.333]                   if (TRUE) {
[17:29:42.333]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.333]                     {
[17:29:42.333]                       inherits <- base::inherits
[17:29:42.333]                       invokeRestart <- base::invokeRestart
[17:29:42.333]                       is.null <- base::is.null
[17:29:42.333]                       muffled <- FALSE
[17:29:42.333]                       if (inherits(cond, "message")) {
[17:29:42.333]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.333]                         if (muffled) 
[17:29:42.333]                           invokeRestart("muffleMessage")
[17:29:42.333]                       }
[17:29:42.333]                       else if (inherits(cond, "warning")) {
[17:29:42.333]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.333]                         if (muffled) 
[17:29:42.333]                           invokeRestart("muffleWarning")
[17:29:42.333]                       }
[17:29:42.333]                       else if (inherits(cond, "condition")) {
[17:29:42.333]                         if (!is.null(pattern)) {
[17:29:42.333]                           computeRestarts <- base::computeRestarts
[17:29:42.333]                           grepl <- base::grepl
[17:29:42.333]                           restarts <- computeRestarts(cond)
[17:29:42.333]                           for (restart in restarts) {
[17:29:42.333]                             name <- restart$name
[17:29:42.333]                             if (is.null(name)) 
[17:29:42.333]                               next
[17:29:42.333]                             if (!grepl(pattern, name)) 
[17:29:42.333]                               next
[17:29:42.333]                             invokeRestart(restart)
[17:29:42.333]                             muffled <- TRUE
[17:29:42.333]                             break
[17:29:42.333]                           }
[17:29:42.333]                         }
[17:29:42.333]                       }
[17:29:42.333]                       invisible(muffled)
[17:29:42.333]                     }
[17:29:42.333]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.333]                   }
[17:29:42.333]                 }
[17:29:42.333]             }
[17:29:42.333]         }))
[17:29:42.333]     }, error = function(ex) {
[17:29:42.333]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.333]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.333]                 ...future.rng), started = ...future.startTime, 
[17:29:42.333]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.333]             version = "1.8"), class = "FutureResult")
[17:29:42.333]     }, finally = {
[17:29:42.333]         if (!identical(...future.workdir, getwd())) 
[17:29:42.333]             setwd(...future.workdir)
[17:29:42.333]         {
[17:29:42.333]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.333]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.333]             }
[17:29:42.333]             base::options(...future.oldOptions)
[17:29:42.333]             if (.Platform$OS.type == "windows") {
[17:29:42.333]                 old_names <- names(...future.oldEnvVars)
[17:29:42.333]                 envs <- base::Sys.getenv()
[17:29:42.333]                 names <- names(envs)
[17:29:42.333]                 common <- intersect(names, old_names)
[17:29:42.333]                 added <- setdiff(names, old_names)
[17:29:42.333]                 removed <- setdiff(old_names, names)
[17:29:42.333]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.333]                   envs[common]]
[17:29:42.333]                 NAMES <- toupper(changed)
[17:29:42.333]                 args <- list()
[17:29:42.333]                 for (kk in seq_along(NAMES)) {
[17:29:42.333]                   name <- changed[[kk]]
[17:29:42.333]                   NAME <- NAMES[[kk]]
[17:29:42.333]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.333]                     next
[17:29:42.333]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.333]                 }
[17:29:42.333]                 NAMES <- toupper(added)
[17:29:42.333]                 for (kk in seq_along(NAMES)) {
[17:29:42.333]                   name <- added[[kk]]
[17:29:42.333]                   NAME <- NAMES[[kk]]
[17:29:42.333]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.333]                     next
[17:29:42.333]                   args[[name]] <- ""
[17:29:42.333]                 }
[17:29:42.333]                 NAMES <- toupper(removed)
[17:29:42.333]                 for (kk in seq_along(NAMES)) {
[17:29:42.333]                   name <- removed[[kk]]
[17:29:42.333]                   NAME <- NAMES[[kk]]
[17:29:42.333]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.333]                     next
[17:29:42.333]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.333]                 }
[17:29:42.333]                 if (length(args) > 0) 
[17:29:42.333]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.333]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.333]             }
[17:29:42.333]             else {
[17:29:42.333]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.333]             }
[17:29:42.333]             {
[17:29:42.333]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.333]                   0L) {
[17:29:42.333]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.333]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.333]                   base::options(opts)
[17:29:42.333]                 }
[17:29:42.333]                 {
[17:29:42.333]                   {
[17:29:42.333]                     base::assign(".Random.seed", c(10407L, -1747872794L, 
[17:29:42.333]                     81576118L, 1436872011L, -1518356641L, -1757990257L, 
[17:29:42.333]                     1928374916L), envir = base::globalenv(), 
[17:29:42.333]                       inherits = FALSE)
[17:29:42.333]                     NULL
[17:29:42.333]                   }
[17:29:42.333]                   options(future.plan = NULL)
[17:29:42.333]                   if (is.na(NA_character_)) 
[17:29:42.333]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.333]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.333]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.333]                     .init = FALSE)
[17:29:42.333]                 }
[17:29:42.333]             }
[17:29:42.333]         }
[17:29:42.333]     })
[17:29:42.333]     if (TRUE) {
[17:29:42.333]         base::sink(type = "output", split = FALSE)
[17:29:42.333]         if (TRUE) {
[17:29:42.333]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.333]         }
[17:29:42.333]         else {
[17:29:42.333]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.333]         }
[17:29:42.333]         base::close(...future.stdout)
[17:29:42.333]         ...future.stdout <- NULL
[17:29:42.333]     }
[17:29:42.333]     ...future.result$conditions <- ...future.conditions
[17:29:42.333]     ...future.result$finished <- base::Sys.time()
[17:29:42.333]     ...future.result
[17:29:42.333] }
[17:29:42.338] assign_globals() ...
[17:29:42.339] List of 1
[17:29:42.339]  $ x: int [1:4] 0 1 2 3
[17:29:42.339]  - attr(*, "where")=List of 1
[17:29:42.339]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.339]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.339]  - attr(*, "resolved")= logi FALSE
[17:29:42.339]  - attr(*, "total_size")= int 133
[17:29:42.339]  - attr(*, "already-done")= logi TRUE
[17:29:42.347] - copied 'x' to environment
[17:29:42.347] assign_globals() ... done
[17:29:42.347] plan(): Setting new future strategy stack:
[17:29:42.348] List of future strategies:
[17:29:42.348] 1. sequential:
[17:29:42.348]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.348]    - tweaked: FALSE
[17:29:42.348]    - call: NULL
[17:29:42.349] plan(): nbrOfWorkers() = 1
[17:29:42.350] plan(): Setting new future strategy stack:
[17:29:42.351] List of future strategies:
[17:29:42.351] 1. sequential:
[17:29:42.351]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.351]    - tweaked: FALSE
[17:29:42.351]    - call: plan(strategy)
[17:29:42.352] plan(): nbrOfWorkers() = 1
[17:29:42.352] SequentialFuture started (and completed)
[17:29:42.352] - Launch lazy future ... done
[17:29:42.352] run() for 'SequentialFuture' ... done
[[1]]
[1] 1

[[2]]
[1] 1

[[3]]
[1] 3

[[4]]
[1] 3

[17:29:42.354] getGlobalsAndPackages() ...
[17:29:42.354] Searching for globals...
[17:29:42.356] - globals found: [3] '{', 'sample', 'x'
[17:29:42.356] Searching for globals ... DONE
[17:29:42.357] Resolving globals: FALSE
[17:29:42.357] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.358] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.358] - globals: [1] 'x'
[17:29:42.358] 
[17:29:42.359] getGlobalsAndPackages() ... DONE
[17:29:42.359] run() for 'Future' ...
[17:29:42.359] - state: 'created'
[17:29:42.360] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.360] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.361] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.361]   - Field: 'label'
[17:29:42.361]   - Field: 'local'
[17:29:42.361]   - Field: 'owner'
[17:29:42.362]   - Field: 'envir'
[17:29:42.362]   - Field: 'packages'
[17:29:42.362]   - Field: 'gc'
[17:29:42.362]   - Field: 'conditions'
[17:29:42.362]   - Field: 'expr'
[17:29:42.363]   - Field: 'uuid'
[17:29:42.363]   - Field: 'seed'
[17:29:42.363]   - Field: 'version'
[17:29:42.363]   - Field: 'result'
[17:29:42.364]   - Field: 'asynchronous'
[17:29:42.364]   - Field: 'calls'
[17:29:42.364]   - Field: 'globals'
[17:29:42.364]   - Field: 'stdout'
[17:29:42.365]   - Field: 'earlySignal'
[17:29:42.365]   - Field: 'lazy'
[17:29:42.365]   - Field: 'state'
[17:29:42.366] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.366] - Launch lazy future ...
[17:29:42.367] Packages needed by the future expression (n = 0): <none>
[17:29:42.367] Packages needed by future strategies (n = 0): <none>
[17:29:42.368] {
[17:29:42.368]     {
[17:29:42.368]         {
[17:29:42.368]             ...future.startTime <- base::Sys.time()
[17:29:42.368]             {
[17:29:42.368]                 {
[17:29:42.368]                   {
[17:29:42.368]                     base::local({
[17:29:42.368]                       has_future <- base::requireNamespace("future", 
[17:29:42.368]                         quietly = TRUE)
[17:29:42.368]                       if (has_future) {
[17:29:42.368]                         ns <- base::getNamespace("future")
[17:29:42.368]                         version <- ns[[".package"]][["version"]]
[17:29:42.368]                         if (is.null(version)) 
[17:29:42.368]                           version <- utils::packageVersion("future")
[17:29:42.368]                       }
[17:29:42.368]                       else {
[17:29:42.368]                         version <- NULL
[17:29:42.368]                       }
[17:29:42.368]                       if (!has_future || version < "1.8.0") {
[17:29:42.368]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.368]                           "", base::R.version$version.string), 
[17:29:42.368]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.368]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.368]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.368]                             "release", "version")], collapse = " "), 
[17:29:42.368]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.368]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.368]                           info)
[17:29:42.368]                         info <- base::paste(info, collapse = "; ")
[17:29:42.368]                         if (!has_future) {
[17:29:42.368]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.368]                             info)
[17:29:42.368]                         }
[17:29:42.368]                         else {
[17:29:42.368]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.368]                             info, version)
[17:29:42.368]                         }
[17:29:42.368]                         base::stop(msg)
[17:29:42.368]                       }
[17:29:42.368]                     })
[17:29:42.368]                   }
[17:29:42.368]                   ...future.strategy.old <- future::plan("list")
[17:29:42.368]                   options(future.plan = NULL)
[17:29:42.368]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.368]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.368]                 }
[17:29:42.368]                 ...future.workdir <- getwd()
[17:29:42.368]             }
[17:29:42.368]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.368]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.368]         }
[17:29:42.368]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.368]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.368]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.368]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.368]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.368]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.368]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.368]             base::names(...future.oldOptions))
[17:29:42.368]     }
[17:29:42.368]     if (FALSE) {
[17:29:42.368]     }
[17:29:42.368]     else {
[17:29:42.368]         if (TRUE) {
[17:29:42.368]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.368]                 open = "w")
[17:29:42.368]         }
[17:29:42.368]         else {
[17:29:42.368]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.368]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.368]         }
[17:29:42.368]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.368]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.368]             base::sink(type = "output", split = FALSE)
[17:29:42.368]             base::close(...future.stdout)
[17:29:42.368]         }, add = TRUE)
[17:29:42.368]     }
[17:29:42.368]     ...future.frame <- base::sys.nframe()
[17:29:42.368]     ...future.conditions <- base::list()
[17:29:42.368]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.368]     if (FALSE) {
[17:29:42.368]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.368]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.368]     }
[17:29:42.368]     ...future.result <- base::tryCatch({
[17:29:42.368]         base::withCallingHandlers({
[17:29:42.368]             ...future.value <- base::withVisible(base::local({
[17:29:42.368]                 sample(x, size = 1L)
[17:29:42.368]             }))
[17:29:42.368]             future::FutureResult(value = ...future.value$value, 
[17:29:42.368]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.368]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.368]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.368]                     ...future.globalenv.names))
[17:29:42.368]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.368]         }, condition = base::local({
[17:29:42.368]             c <- base::c
[17:29:42.368]             inherits <- base::inherits
[17:29:42.368]             invokeRestart <- base::invokeRestart
[17:29:42.368]             length <- base::length
[17:29:42.368]             list <- base::list
[17:29:42.368]             seq.int <- base::seq.int
[17:29:42.368]             signalCondition <- base::signalCondition
[17:29:42.368]             sys.calls <- base::sys.calls
[17:29:42.368]             `[[` <- base::`[[`
[17:29:42.368]             `+` <- base::`+`
[17:29:42.368]             `<<-` <- base::`<<-`
[17:29:42.368]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.368]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.368]                   3L)]
[17:29:42.368]             }
[17:29:42.368]             function(cond) {
[17:29:42.368]                 is_error <- inherits(cond, "error")
[17:29:42.368]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.368]                   NULL)
[17:29:42.368]                 if (is_error) {
[17:29:42.368]                   sessionInformation <- function() {
[17:29:42.368]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.368]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.368]                       search = base::search(), system = base::Sys.info())
[17:29:42.368]                   }
[17:29:42.368]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.368]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.368]                     cond$call), session = sessionInformation(), 
[17:29:42.368]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.368]                   signalCondition(cond)
[17:29:42.368]                 }
[17:29:42.368]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.368]                 "immediateCondition"))) {
[17:29:42.368]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.368]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.368]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.368]                   if (TRUE && !signal) {
[17:29:42.368]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.368]                     {
[17:29:42.368]                       inherits <- base::inherits
[17:29:42.368]                       invokeRestart <- base::invokeRestart
[17:29:42.368]                       is.null <- base::is.null
[17:29:42.368]                       muffled <- FALSE
[17:29:42.368]                       if (inherits(cond, "message")) {
[17:29:42.368]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.368]                         if (muffled) 
[17:29:42.368]                           invokeRestart("muffleMessage")
[17:29:42.368]                       }
[17:29:42.368]                       else if (inherits(cond, "warning")) {
[17:29:42.368]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.368]                         if (muffled) 
[17:29:42.368]                           invokeRestart("muffleWarning")
[17:29:42.368]                       }
[17:29:42.368]                       else if (inherits(cond, "condition")) {
[17:29:42.368]                         if (!is.null(pattern)) {
[17:29:42.368]                           computeRestarts <- base::computeRestarts
[17:29:42.368]                           grepl <- base::grepl
[17:29:42.368]                           restarts <- computeRestarts(cond)
[17:29:42.368]                           for (restart in restarts) {
[17:29:42.368]                             name <- restart$name
[17:29:42.368]                             if (is.null(name)) 
[17:29:42.368]                               next
[17:29:42.368]                             if (!grepl(pattern, name)) 
[17:29:42.368]                               next
[17:29:42.368]                             invokeRestart(restart)
[17:29:42.368]                             muffled <- TRUE
[17:29:42.368]                             break
[17:29:42.368]                           }
[17:29:42.368]                         }
[17:29:42.368]                       }
[17:29:42.368]                       invisible(muffled)
[17:29:42.368]                     }
[17:29:42.368]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.368]                   }
[17:29:42.368]                 }
[17:29:42.368]                 else {
[17:29:42.368]                   if (TRUE) {
[17:29:42.368]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.368]                     {
[17:29:42.368]                       inherits <- base::inherits
[17:29:42.368]                       invokeRestart <- base::invokeRestart
[17:29:42.368]                       is.null <- base::is.null
[17:29:42.368]                       muffled <- FALSE
[17:29:42.368]                       if (inherits(cond, "message")) {
[17:29:42.368]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.368]                         if (muffled) 
[17:29:42.368]                           invokeRestart("muffleMessage")
[17:29:42.368]                       }
[17:29:42.368]                       else if (inherits(cond, "warning")) {
[17:29:42.368]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.368]                         if (muffled) 
[17:29:42.368]                           invokeRestart("muffleWarning")
[17:29:42.368]                       }
[17:29:42.368]                       else if (inherits(cond, "condition")) {
[17:29:42.368]                         if (!is.null(pattern)) {
[17:29:42.368]                           computeRestarts <- base::computeRestarts
[17:29:42.368]                           grepl <- base::grepl
[17:29:42.368]                           restarts <- computeRestarts(cond)
[17:29:42.368]                           for (restart in restarts) {
[17:29:42.368]                             name <- restart$name
[17:29:42.368]                             if (is.null(name)) 
[17:29:42.368]                               next
[17:29:42.368]                             if (!grepl(pattern, name)) 
[17:29:42.368]                               next
[17:29:42.368]                             invokeRestart(restart)
[17:29:42.368]                             muffled <- TRUE
[17:29:42.368]                             break
[17:29:42.368]                           }
[17:29:42.368]                         }
[17:29:42.368]                       }
[17:29:42.368]                       invisible(muffled)
[17:29:42.368]                     }
[17:29:42.368]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.368]                   }
[17:29:42.368]                 }
[17:29:42.368]             }
[17:29:42.368]         }))
[17:29:42.368]     }, error = function(ex) {
[17:29:42.368]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.368]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.368]                 ...future.rng), started = ...future.startTime, 
[17:29:42.368]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.368]             version = "1.8"), class = "FutureResult")
[17:29:42.368]     }, finally = {
[17:29:42.368]         if (!identical(...future.workdir, getwd())) 
[17:29:42.368]             setwd(...future.workdir)
[17:29:42.368]         {
[17:29:42.368]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.368]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.368]             }
[17:29:42.368]             base::options(...future.oldOptions)
[17:29:42.368]             if (.Platform$OS.type == "windows") {
[17:29:42.368]                 old_names <- names(...future.oldEnvVars)
[17:29:42.368]                 envs <- base::Sys.getenv()
[17:29:42.368]                 names <- names(envs)
[17:29:42.368]                 common <- intersect(names, old_names)
[17:29:42.368]                 added <- setdiff(names, old_names)
[17:29:42.368]                 removed <- setdiff(old_names, names)
[17:29:42.368]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.368]                   envs[common]]
[17:29:42.368]                 NAMES <- toupper(changed)
[17:29:42.368]                 args <- list()
[17:29:42.368]                 for (kk in seq_along(NAMES)) {
[17:29:42.368]                   name <- changed[[kk]]
[17:29:42.368]                   NAME <- NAMES[[kk]]
[17:29:42.368]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.368]                     next
[17:29:42.368]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.368]                 }
[17:29:42.368]                 NAMES <- toupper(added)
[17:29:42.368]                 for (kk in seq_along(NAMES)) {
[17:29:42.368]                   name <- added[[kk]]
[17:29:42.368]                   NAME <- NAMES[[kk]]
[17:29:42.368]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.368]                     next
[17:29:42.368]                   args[[name]] <- ""
[17:29:42.368]                 }
[17:29:42.368]                 NAMES <- toupper(removed)
[17:29:42.368]                 for (kk in seq_along(NAMES)) {
[17:29:42.368]                   name <- removed[[kk]]
[17:29:42.368]                   NAME <- NAMES[[kk]]
[17:29:42.368]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.368]                     next
[17:29:42.368]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.368]                 }
[17:29:42.368]                 if (length(args) > 0) 
[17:29:42.368]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.368]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.368]             }
[17:29:42.368]             else {
[17:29:42.368]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.368]             }
[17:29:42.368]             {
[17:29:42.368]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.368]                   0L) {
[17:29:42.368]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.368]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.368]                   base::options(opts)
[17:29:42.368]                 }
[17:29:42.368]                 {
[17:29:42.368]                   {
[17:29:42.368]                     base::assign(".Random.seed", c(10407L, 1905472070L, 
[17:29:42.368]                     548552339L, -2132515101L, -5027275L, -1254720561L, 
[17:29:42.368]                     -249581963L), envir = base::globalenv(), 
[17:29:42.368]                       inherits = FALSE)
[17:29:42.368]                     NULL
[17:29:42.368]                   }
[17:29:42.368]                   options(future.plan = NULL)
[17:29:42.368]                   if (is.na(NA_character_)) 
[17:29:42.368]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.368]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.368]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.368]                     .init = FALSE)
[17:29:42.368]                 }
[17:29:42.368]             }
[17:29:42.368]         }
[17:29:42.368]     })
[17:29:42.368]     if (TRUE) {
[17:29:42.368]         base::sink(type = "output", split = FALSE)
[17:29:42.368]         if (TRUE) {
[17:29:42.368]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.368]         }
[17:29:42.368]         else {
[17:29:42.368]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.368]         }
[17:29:42.368]         base::close(...future.stdout)
[17:29:42.368]         ...future.stdout <- NULL
[17:29:42.368]     }
[17:29:42.368]     ...future.result$conditions <- ...future.conditions
[17:29:42.368]     ...future.result$finished <- base::Sys.time()
[17:29:42.368]     ...future.result
[17:29:42.368] }
[17:29:42.375] assign_globals() ...
[17:29:42.375] List of 1
[17:29:42.375]  $ x: int [1:4] 0 1 2 3
[17:29:42.375]  - attr(*, "where")=List of 1
[17:29:42.375]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.375]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.375]  - attr(*, "resolved")= logi FALSE
[17:29:42.375]  - attr(*, "total_size")= int 133
[17:29:42.375]  - attr(*, "already-done")= logi TRUE
[17:29:42.381] - copied 'x' to environment
[17:29:42.382] assign_globals() ... done
[17:29:42.382] plan(): Setting new future strategy stack:
[17:29:42.383] List of future strategies:
[17:29:42.383] 1. sequential:
[17:29:42.383]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.383]    - tweaked: FALSE
[17:29:42.383]    - call: NULL
[17:29:42.384] plan(): nbrOfWorkers() = 1
[17:29:42.386] plan(): Setting new future strategy stack:
[17:29:42.386] List of future strategies:
[17:29:42.386] 1. sequential:
[17:29:42.386]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.386]    - tweaked: FALSE
[17:29:42.386]    - call: plan(strategy)
[17:29:42.391] plan(): nbrOfWorkers() = 1
[17:29:42.391] SequentialFuture started (and completed)
[17:29:42.392] - Launch lazy future ... done
[17:29:42.392] run() for 'SequentialFuture' ... done
[17:29:42.393] getGlobalsAndPackages() ...
[17:29:42.394] Searching for globals...
[17:29:42.396] - globals found: [3] '{', 'sample', 'x'
[17:29:42.397] Searching for globals ... DONE
[17:29:42.397] Resolving globals: FALSE
[17:29:42.398] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.399] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.399] - globals: [1] 'x'
[17:29:42.400] 
[17:29:42.400] getGlobalsAndPackages() ... DONE
[17:29:42.400] run() for 'Future' ...
[17:29:42.401] - state: 'created'
[17:29:42.401] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.402] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.402] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.403]   - Field: 'label'
[17:29:42.403]   - Field: 'local'
[17:29:42.404]   - Field: 'owner'
[17:29:42.404]   - Field: 'envir'
[17:29:42.404]   - Field: 'packages'
[17:29:42.405]   - Field: 'gc'
[17:29:42.405]   - Field: 'conditions'
[17:29:42.405]   - Field: 'expr'
[17:29:42.406]   - Field: 'uuid'
[17:29:42.406]   - Field: 'seed'
[17:29:42.406]   - Field: 'version'
[17:29:42.407]   - Field: 'result'
[17:29:42.407]   - Field: 'asynchronous'
[17:29:42.407]   - Field: 'calls'
[17:29:42.408]   - Field: 'globals'
[17:29:42.408]   - Field: 'stdout'
[17:29:42.408]   - Field: 'earlySignal'
[17:29:42.409]   - Field: 'lazy'
[17:29:42.409]   - Field: 'state'
[17:29:42.409] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.410] - Launch lazy future ...
[17:29:42.410] Packages needed by the future expression (n = 0): <none>
[17:29:42.411] Packages needed by future strategies (n = 0): <none>
[17:29:42.412] {
[17:29:42.412]     {
[17:29:42.412]         {
[17:29:42.412]             ...future.startTime <- base::Sys.time()
[17:29:42.412]             {
[17:29:42.412]                 {
[17:29:42.412]                   {
[17:29:42.412]                     base::local({
[17:29:42.412]                       has_future <- base::requireNamespace("future", 
[17:29:42.412]                         quietly = TRUE)
[17:29:42.412]                       if (has_future) {
[17:29:42.412]                         ns <- base::getNamespace("future")
[17:29:42.412]                         version <- ns[[".package"]][["version"]]
[17:29:42.412]                         if (is.null(version)) 
[17:29:42.412]                           version <- utils::packageVersion("future")
[17:29:42.412]                       }
[17:29:42.412]                       else {
[17:29:42.412]                         version <- NULL
[17:29:42.412]                       }
[17:29:42.412]                       if (!has_future || version < "1.8.0") {
[17:29:42.412]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.412]                           "", base::R.version$version.string), 
[17:29:42.412]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.412]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.412]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.412]                             "release", "version")], collapse = " "), 
[17:29:42.412]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.412]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.412]                           info)
[17:29:42.412]                         info <- base::paste(info, collapse = "; ")
[17:29:42.412]                         if (!has_future) {
[17:29:42.412]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.412]                             info)
[17:29:42.412]                         }
[17:29:42.412]                         else {
[17:29:42.412]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.412]                             info, version)
[17:29:42.412]                         }
[17:29:42.412]                         base::stop(msg)
[17:29:42.412]                       }
[17:29:42.412]                     })
[17:29:42.412]                   }
[17:29:42.412]                   ...future.strategy.old <- future::plan("list")
[17:29:42.412]                   options(future.plan = NULL)
[17:29:42.412]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.412]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.412]                 }
[17:29:42.412]                 ...future.workdir <- getwd()
[17:29:42.412]             }
[17:29:42.412]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.412]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.412]         }
[17:29:42.412]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.412]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.412]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.412]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.412]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.412]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.412]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.412]             base::names(...future.oldOptions))
[17:29:42.412]     }
[17:29:42.412]     if (FALSE) {
[17:29:42.412]     }
[17:29:42.412]     else {
[17:29:42.412]         if (TRUE) {
[17:29:42.412]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.412]                 open = "w")
[17:29:42.412]         }
[17:29:42.412]         else {
[17:29:42.412]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.412]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.412]         }
[17:29:42.412]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.412]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.412]             base::sink(type = "output", split = FALSE)
[17:29:42.412]             base::close(...future.stdout)
[17:29:42.412]         }, add = TRUE)
[17:29:42.412]     }
[17:29:42.412]     ...future.frame <- base::sys.nframe()
[17:29:42.412]     ...future.conditions <- base::list()
[17:29:42.412]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.412]     if (FALSE) {
[17:29:42.412]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.412]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.412]     }
[17:29:42.412]     ...future.result <- base::tryCatch({
[17:29:42.412]         base::withCallingHandlers({
[17:29:42.412]             ...future.value <- base::withVisible(base::local({
[17:29:42.412]                 sample(x, size = 1L)
[17:29:42.412]             }))
[17:29:42.412]             future::FutureResult(value = ...future.value$value, 
[17:29:42.412]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.412]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.412]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.412]                     ...future.globalenv.names))
[17:29:42.412]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.412]         }, condition = base::local({
[17:29:42.412]             c <- base::c
[17:29:42.412]             inherits <- base::inherits
[17:29:42.412]             invokeRestart <- base::invokeRestart
[17:29:42.412]             length <- base::length
[17:29:42.412]             list <- base::list
[17:29:42.412]             seq.int <- base::seq.int
[17:29:42.412]             signalCondition <- base::signalCondition
[17:29:42.412]             sys.calls <- base::sys.calls
[17:29:42.412]             `[[` <- base::`[[`
[17:29:42.412]             `+` <- base::`+`
[17:29:42.412]             `<<-` <- base::`<<-`
[17:29:42.412]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.412]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.412]                   3L)]
[17:29:42.412]             }
[17:29:42.412]             function(cond) {
[17:29:42.412]                 is_error <- inherits(cond, "error")
[17:29:42.412]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.412]                   NULL)
[17:29:42.412]                 if (is_error) {
[17:29:42.412]                   sessionInformation <- function() {
[17:29:42.412]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.412]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.412]                       search = base::search(), system = base::Sys.info())
[17:29:42.412]                   }
[17:29:42.412]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.412]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.412]                     cond$call), session = sessionInformation(), 
[17:29:42.412]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.412]                   signalCondition(cond)
[17:29:42.412]                 }
[17:29:42.412]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.412]                 "immediateCondition"))) {
[17:29:42.412]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.412]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.412]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.412]                   if (TRUE && !signal) {
[17:29:42.412]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.412]                     {
[17:29:42.412]                       inherits <- base::inherits
[17:29:42.412]                       invokeRestart <- base::invokeRestart
[17:29:42.412]                       is.null <- base::is.null
[17:29:42.412]                       muffled <- FALSE
[17:29:42.412]                       if (inherits(cond, "message")) {
[17:29:42.412]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.412]                         if (muffled) 
[17:29:42.412]                           invokeRestart("muffleMessage")
[17:29:42.412]                       }
[17:29:42.412]                       else if (inherits(cond, "warning")) {
[17:29:42.412]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.412]                         if (muffled) 
[17:29:42.412]                           invokeRestart("muffleWarning")
[17:29:42.412]                       }
[17:29:42.412]                       else if (inherits(cond, "condition")) {
[17:29:42.412]                         if (!is.null(pattern)) {
[17:29:42.412]                           computeRestarts <- base::computeRestarts
[17:29:42.412]                           grepl <- base::grepl
[17:29:42.412]                           restarts <- computeRestarts(cond)
[17:29:42.412]                           for (restart in restarts) {
[17:29:42.412]                             name <- restart$name
[17:29:42.412]                             if (is.null(name)) 
[17:29:42.412]                               next
[17:29:42.412]                             if (!grepl(pattern, name)) 
[17:29:42.412]                               next
[17:29:42.412]                             invokeRestart(restart)
[17:29:42.412]                             muffled <- TRUE
[17:29:42.412]                             break
[17:29:42.412]                           }
[17:29:42.412]                         }
[17:29:42.412]                       }
[17:29:42.412]                       invisible(muffled)
[17:29:42.412]                     }
[17:29:42.412]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.412]                   }
[17:29:42.412]                 }
[17:29:42.412]                 else {
[17:29:42.412]                   if (TRUE) {
[17:29:42.412]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.412]                     {
[17:29:42.412]                       inherits <- base::inherits
[17:29:42.412]                       invokeRestart <- base::invokeRestart
[17:29:42.412]                       is.null <- base::is.null
[17:29:42.412]                       muffled <- FALSE
[17:29:42.412]                       if (inherits(cond, "message")) {
[17:29:42.412]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.412]                         if (muffled) 
[17:29:42.412]                           invokeRestart("muffleMessage")
[17:29:42.412]                       }
[17:29:42.412]                       else if (inherits(cond, "warning")) {
[17:29:42.412]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.412]                         if (muffled) 
[17:29:42.412]                           invokeRestart("muffleWarning")
[17:29:42.412]                       }
[17:29:42.412]                       else if (inherits(cond, "condition")) {
[17:29:42.412]                         if (!is.null(pattern)) {
[17:29:42.412]                           computeRestarts <- base::computeRestarts
[17:29:42.412]                           grepl <- base::grepl
[17:29:42.412]                           restarts <- computeRestarts(cond)
[17:29:42.412]                           for (restart in restarts) {
[17:29:42.412]                             name <- restart$name
[17:29:42.412]                             if (is.null(name)) 
[17:29:42.412]                               next
[17:29:42.412]                             if (!grepl(pattern, name)) 
[17:29:42.412]                               next
[17:29:42.412]                             invokeRestart(restart)
[17:29:42.412]                             muffled <- TRUE
[17:29:42.412]                             break
[17:29:42.412]                           }
[17:29:42.412]                         }
[17:29:42.412]                       }
[17:29:42.412]                       invisible(muffled)
[17:29:42.412]                     }
[17:29:42.412]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.412]                   }
[17:29:42.412]                 }
[17:29:42.412]             }
[17:29:42.412]         }))
[17:29:42.412]     }, error = function(ex) {
[17:29:42.412]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.412]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.412]                 ...future.rng), started = ...future.startTime, 
[17:29:42.412]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.412]             version = "1.8"), class = "FutureResult")
[17:29:42.412]     }, finally = {
[17:29:42.412]         if (!identical(...future.workdir, getwd())) 
[17:29:42.412]             setwd(...future.workdir)
[17:29:42.412]         {
[17:29:42.412]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.412]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.412]             }
[17:29:42.412]             base::options(...future.oldOptions)
[17:29:42.412]             if (.Platform$OS.type == "windows") {
[17:29:42.412]                 old_names <- names(...future.oldEnvVars)
[17:29:42.412]                 envs <- base::Sys.getenv()
[17:29:42.412]                 names <- names(envs)
[17:29:42.412]                 common <- intersect(names, old_names)
[17:29:42.412]                 added <- setdiff(names, old_names)
[17:29:42.412]                 removed <- setdiff(old_names, names)
[17:29:42.412]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.412]                   envs[common]]
[17:29:42.412]                 NAMES <- toupper(changed)
[17:29:42.412]                 args <- list()
[17:29:42.412]                 for (kk in seq_along(NAMES)) {
[17:29:42.412]                   name <- changed[[kk]]
[17:29:42.412]                   NAME <- NAMES[[kk]]
[17:29:42.412]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.412]                     next
[17:29:42.412]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.412]                 }
[17:29:42.412]                 NAMES <- toupper(added)
[17:29:42.412]                 for (kk in seq_along(NAMES)) {
[17:29:42.412]                   name <- added[[kk]]
[17:29:42.412]                   NAME <- NAMES[[kk]]
[17:29:42.412]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.412]                     next
[17:29:42.412]                   args[[name]] <- ""
[17:29:42.412]                 }
[17:29:42.412]                 NAMES <- toupper(removed)
[17:29:42.412]                 for (kk in seq_along(NAMES)) {
[17:29:42.412]                   name <- removed[[kk]]
[17:29:42.412]                   NAME <- NAMES[[kk]]
[17:29:42.412]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.412]                     next
[17:29:42.412]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.412]                 }
[17:29:42.412]                 if (length(args) > 0) 
[17:29:42.412]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.412]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.412]             }
[17:29:42.412]             else {
[17:29:42.412]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.412]             }
[17:29:42.412]             {
[17:29:42.412]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.412]                   0L) {
[17:29:42.412]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.412]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.412]                   base::options(opts)
[17:29:42.412]                 }
[17:29:42.412]                 {
[17:29:42.412]                   {
[17:29:42.412]                     base::assign(".Random.seed", c(10407L, -2132515101L, 
[17:29:42.412]                     -1686425357L, -1357819733L, -249581963L, 
[17:29:42.412]                     -289910035L, -92677537L), envir = base::globalenv(), 
[17:29:42.412]                       inherits = FALSE)
[17:29:42.412]                     NULL
[17:29:42.412]                   }
[17:29:42.412]                   options(future.plan = NULL)
[17:29:42.412]                   if (is.na(NA_character_)) 
[17:29:42.412]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.412]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.412]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.412]                     .init = FALSE)
[17:29:42.412]                 }
[17:29:42.412]             }
[17:29:42.412]         }
[17:29:42.412]     })
[17:29:42.412]     if (TRUE) {
[17:29:42.412]         base::sink(type = "output", split = FALSE)
[17:29:42.412]         if (TRUE) {
[17:29:42.412]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.412]         }
[17:29:42.412]         else {
[17:29:42.412]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.412]         }
[17:29:42.412]         base::close(...future.stdout)
[17:29:42.412]         ...future.stdout <- NULL
[17:29:42.412]     }
[17:29:42.412]     ...future.result$conditions <- ...future.conditions
[17:29:42.412]     ...future.result$finished <- base::Sys.time()
[17:29:42.412]     ...future.result
[17:29:42.412] }
[17:29:42.418] assign_globals() ...
[17:29:42.418] List of 1
[17:29:42.418]  $ x: int [1:4] 0 1 2 3
[17:29:42.418]  - attr(*, "where")=List of 1
[17:29:42.418]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.418]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.418]  - attr(*, "resolved")= logi FALSE
[17:29:42.418]  - attr(*, "total_size")= int 133
[17:29:42.418]  - attr(*, "already-done")= logi TRUE
[17:29:42.424] - copied 'x' to environment
[17:29:42.425] assign_globals() ... done
[17:29:42.425] plan(): Setting new future strategy stack:
[17:29:42.426] List of future strategies:
[17:29:42.426] 1. sequential:
[17:29:42.426]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.426]    - tweaked: FALSE
[17:29:42.426]    - call: NULL
[17:29:42.427] plan(): nbrOfWorkers() = 1
[17:29:42.429] plan(): Setting new future strategy stack:
[17:29:42.430] List of future strategies:
[17:29:42.430] 1. sequential:
[17:29:42.430]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.430]    - tweaked: FALSE
[17:29:42.430]    - call: plan(strategy)
[17:29:42.431] plan(): nbrOfWorkers() = 1
[17:29:42.431] SequentialFuture started (and completed)
[17:29:42.432] - Launch lazy future ... done
[17:29:42.432] run() for 'SequentialFuture' ... done
[17:29:42.433] getGlobalsAndPackages() ...
[17:29:42.433] Searching for globals...
[17:29:42.435] - globals found: [3] '{', 'sample', 'x'
[17:29:42.435] Searching for globals ... DONE
[17:29:42.436] Resolving globals: FALSE
[17:29:42.436] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.437] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.437] - globals: [1] 'x'
[17:29:42.438] 
[17:29:42.438] getGlobalsAndPackages() ... DONE
[17:29:42.438] run() for 'Future' ...
[17:29:42.439] - state: 'created'
[17:29:42.439] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.440] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.440] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.440]   - Field: 'label'
[17:29:42.440]   - Field: 'local'
[17:29:42.441]   - Field: 'owner'
[17:29:42.441]   - Field: 'envir'
[17:29:42.444]   - Field: 'packages'
[17:29:42.445]   - Field: 'gc'
[17:29:42.445]   - Field: 'conditions'
[17:29:42.445]   - Field: 'expr'
[17:29:42.445]   - Field: 'uuid'
[17:29:42.446]   - Field: 'seed'
[17:29:42.446]   - Field: 'version'
[17:29:42.446]   - Field: 'result'
[17:29:42.447]   - Field: 'asynchronous'
[17:29:42.447]   - Field: 'calls'
[17:29:42.447]   - Field: 'globals'
[17:29:42.448]   - Field: 'stdout'
[17:29:42.448]   - Field: 'earlySignal'
[17:29:42.448]   - Field: 'lazy'
[17:29:42.448]   - Field: 'state'
[17:29:42.449] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.449] - Launch lazy future ...
[17:29:42.450] Packages needed by the future expression (n = 0): <none>
[17:29:42.450] Packages needed by future strategies (n = 0): <none>
[17:29:42.451] {
[17:29:42.451]     {
[17:29:42.451]         {
[17:29:42.451]             ...future.startTime <- base::Sys.time()
[17:29:42.451]             {
[17:29:42.451]                 {
[17:29:42.451]                   {
[17:29:42.451]                     base::local({
[17:29:42.451]                       has_future <- base::requireNamespace("future", 
[17:29:42.451]                         quietly = TRUE)
[17:29:42.451]                       if (has_future) {
[17:29:42.451]                         ns <- base::getNamespace("future")
[17:29:42.451]                         version <- ns[[".package"]][["version"]]
[17:29:42.451]                         if (is.null(version)) 
[17:29:42.451]                           version <- utils::packageVersion("future")
[17:29:42.451]                       }
[17:29:42.451]                       else {
[17:29:42.451]                         version <- NULL
[17:29:42.451]                       }
[17:29:42.451]                       if (!has_future || version < "1.8.0") {
[17:29:42.451]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.451]                           "", base::R.version$version.string), 
[17:29:42.451]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.451]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.451]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.451]                             "release", "version")], collapse = " "), 
[17:29:42.451]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.451]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.451]                           info)
[17:29:42.451]                         info <- base::paste(info, collapse = "; ")
[17:29:42.451]                         if (!has_future) {
[17:29:42.451]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.451]                             info)
[17:29:42.451]                         }
[17:29:42.451]                         else {
[17:29:42.451]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.451]                             info, version)
[17:29:42.451]                         }
[17:29:42.451]                         base::stop(msg)
[17:29:42.451]                       }
[17:29:42.451]                     })
[17:29:42.451]                   }
[17:29:42.451]                   ...future.strategy.old <- future::plan("list")
[17:29:42.451]                   options(future.plan = NULL)
[17:29:42.451]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.451]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.451]                 }
[17:29:42.451]                 ...future.workdir <- getwd()
[17:29:42.451]             }
[17:29:42.451]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.451]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.451]         }
[17:29:42.451]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.451]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.451]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.451]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.451]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.451]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.451]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.451]             base::names(...future.oldOptions))
[17:29:42.451]     }
[17:29:42.451]     if (FALSE) {
[17:29:42.451]     }
[17:29:42.451]     else {
[17:29:42.451]         if (TRUE) {
[17:29:42.451]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.451]                 open = "w")
[17:29:42.451]         }
[17:29:42.451]         else {
[17:29:42.451]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.451]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.451]         }
[17:29:42.451]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.451]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.451]             base::sink(type = "output", split = FALSE)
[17:29:42.451]             base::close(...future.stdout)
[17:29:42.451]         }, add = TRUE)
[17:29:42.451]     }
[17:29:42.451]     ...future.frame <- base::sys.nframe()
[17:29:42.451]     ...future.conditions <- base::list()
[17:29:42.451]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.451]     if (FALSE) {
[17:29:42.451]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.451]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.451]     }
[17:29:42.451]     ...future.result <- base::tryCatch({
[17:29:42.451]         base::withCallingHandlers({
[17:29:42.451]             ...future.value <- base::withVisible(base::local({
[17:29:42.451]                 sample(x, size = 1L)
[17:29:42.451]             }))
[17:29:42.451]             future::FutureResult(value = ...future.value$value, 
[17:29:42.451]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.451]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.451]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.451]                     ...future.globalenv.names))
[17:29:42.451]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.451]         }, condition = base::local({
[17:29:42.451]             c <- base::c
[17:29:42.451]             inherits <- base::inherits
[17:29:42.451]             invokeRestart <- base::invokeRestart
[17:29:42.451]             length <- base::length
[17:29:42.451]             list <- base::list
[17:29:42.451]             seq.int <- base::seq.int
[17:29:42.451]             signalCondition <- base::signalCondition
[17:29:42.451]             sys.calls <- base::sys.calls
[17:29:42.451]             `[[` <- base::`[[`
[17:29:42.451]             `+` <- base::`+`
[17:29:42.451]             `<<-` <- base::`<<-`
[17:29:42.451]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.451]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.451]                   3L)]
[17:29:42.451]             }
[17:29:42.451]             function(cond) {
[17:29:42.451]                 is_error <- inherits(cond, "error")
[17:29:42.451]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.451]                   NULL)
[17:29:42.451]                 if (is_error) {
[17:29:42.451]                   sessionInformation <- function() {
[17:29:42.451]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.451]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.451]                       search = base::search(), system = base::Sys.info())
[17:29:42.451]                   }
[17:29:42.451]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.451]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.451]                     cond$call), session = sessionInformation(), 
[17:29:42.451]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.451]                   signalCondition(cond)
[17:29:42.451]                 }
[17:29:42.451]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.451]                 "immediateCondition"))) {
[17:29:42.451]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.451]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.451]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.451]                   if (TRUE && !signal) {
[17:29:42.451]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.451]                     {
[17:29:42.451]                       inherits <- base::inherits
[17:29:42.451]                       invokeRestart <- base::invokeRestart
[17:29:42.451]                       is.null <- base::is.null
[17:29:42.451]                       muffled <- FALSE
[17:29:42.451]                       if (inherits(cond, "message")) {
[17:29:42.451]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.451]                         if (muffled) 
[17:29:42.451]                           invokeRestart("muffleMessage")
[17:29:42.451]                       }
[17:29:42.451]                       else if (inherits(cond, "warning")) {
[17:29:42.451]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.451]                         if (muffled) 
[17:29:42.451]                           invokeRestart("muffleWarning")
[17:29:42.451]                       }
[17:29:42.451]                       else if (inherits(cond, "condition")) {
[17:29:42.451]                         if (!is.null(pattern)) {
[17:29:42.451]                           computeRestarts <- base::computeRestarts
[17:29:42.451]                           grepl <- base::grepl
[17:29:42.451]                           restarts <- computeRestarts(cond)
[17:29:42.451]                           for (restart in restarts) {
[17:29:42.451]                             name <- restart$name
[17:29:42.451]                             if (is.null(name)) 
[17:29:42.451]                               next
[17:29:42.451]                             if (!grepl(pattern, name)) 
[17:29:42.451]                               next
[17:29:42.451]                             invokeRestart(restart)
[17:29:42.451]                             muffled <- TRUE
[17:29:42.451]                             break
[17:29:42.451]                           }
[17:29:42.451]                         }
[17:29:42.451]                       }
[17:29:42.451]                       invisible(muffled)
[17:29:42.451]                     }
[17:29:42.451]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.451]                   }
[17:29:42.451]                 }
[17:29:42.451]                 else {
[17:29:42.451]                   if (TRUE) {
[17:29:42.451]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.451]                     {
[17:29:42.451]                       inherits <- base::inherits
[17:29:42.451]                       invokeRestart <- base::invokeRestart
[17:29:42.451]                       is.null <- base::is.null
[17:29:42.451]                       muffled <- FALSE
[17:29:42.451]                       if (inherits(cond, "message")) {
[17:29:42.451]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.451]                         if (muffled) 
[17:29:42.451]                           invokeRestart("muffleMessage")
[17:29:42.451]                       }
[17:29:42.451]                       else if (inherits(cond, "warning")) {
[17:29:42.451]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.451]                         if (muffled) 
[17:29:42.451]                           invokeRestart("muffleWarning")
[17:29:42.451]                       }
[17:29:42.451]                       else if (inherits(cond, "condition")) {
[17:29:42.451]                         if (!is.null(pattern)) {
[17:29:42.451]                           computeRestarts <- base::computeRestarts
[17:29:42.451]                           grepl <- base::grepl
[17:29:42.451]                           restarts <- computeRestarts(cond)
[17:29:42.451]                           for (restart in restarts) {
[17:29:42.451]                             name <- restart$name
[17:29:42.451]                             if (is.null(name)) 
[17:29:42.451]                               next
[17:29:42.451]                             if (!grepl(pattern, name)) 
[17:29:42.451]                               next
[17:29:42.451]                             invokeRestart(restart)
[17:29:42.451]                             muffled <- TRUE
[17:29:42.451]                             break
[17:29:42.451]                           }
[17:29:42.451]                         }
[17:29:42.451]                       }
[17:29:42.451]                       invisible(muffled)
[17:29:42.451]                     }
[17:29:42.451]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.451]                   }
[17:29:42.451]                 }
[17:29:42.451]             }
[17:29:42.451]         }))
[17:29:42.451]     }, error = function(ex) {
[17:29:42.451]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.451]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.451]                 ...future.rng), started = ...future.startTime, 
[17:29:42.451]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.451]             version = "1.8"), class = "FutureResult")
[17:29:42.451]     }, finally = {
[17:29:42.451]         if (!identical(...future.workdir, getwd())) 
[17:29:42.451]             setwd(...future.workdir)
[17:29:42.451]         {
[17:29:42.451]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.451]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.451]             }
[17:29:42.451]             base::options(...future.oldOptions)
[17:29:42.451]             if (.Platform$OS.type == "windows") {
[17:29:42.451]                 old_names <- names(...future.oldEnvVars)
[17:29:42.451]                 envs <- base::Sys.getenv()
[17:29:42.451]                 names <- names(envs)
[17:29:42.451]                 common <- intersect(names, old_names)
[17:29:42.451]                 added <- setdiff(names, old_names)
[17:29:42.451]                 removed <- setdiff(old_names, names)
[17:29:42.451]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.451]                   envs[common]]
[17:29:42.451]                 NAMES <- toupper(changed)
[17:29:42.451]                 args <- list()
[17:29:42.451]                 for (kk in seq_along(NAMES)) {
[17:29:42.451]                   name <- changed[[kk]]
[17:29:42.451]                   NAME <- NAMES[[kk]]
[17:29:42.451]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.451]                     next
[17:29:42.451]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.451]                 }
[17:29:42.451]                 NAMES <- toupper(added)
[17:29:42.451]                 for (kk in seq_along(NAMES)) {
[17:29:42.451]                   name <- added[[kk]]
[17:29:42.451]                   NAME <- NAMES[[kk]]
[17:29:42.451]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.451]                     next
[17:29:42.451]                   args[[name]] <- ""
[17:29:42.451]                 }
[17:29:42.451]                 NAMES <- toupper(removed)
[17:29:42.451]                 for (kk in seq_along(NAMES)) {
[17:29:42.451]                   name <- removed[[kk]]
[17:29:42.451]                   NAME <- NAMES[[kk]]
[17:29:42.451]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.451]                     next
[17:29:42.451]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.451]                 }
[17:29:42.451]                 if (length(args) > 0) 
[17:29:42.451]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.451]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.451]             }
[17:29:42.451]             else {
[17:29:42.451]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.451]             }
[17:29:42.451]             {
[17:29:42.451]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.451]                   0L) {
[17:29:42.451]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.451]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.451]                   base::options(opts)
[17:29:42.451]                 }
[17:29:42.451]                 {
[17:29:42.451]                   {
[17:29:42.451]                     base::assign(".Random.seed", c(10407L, -1357819733L, 
[17:29:42.451]                     -1161049300L, -252299846L, -92677537L, 1519979774L, 
[17:29:42.451]                     -1585431857L), envir = base::globalenv(), 
[17:29:42.451]                       inherits = FALSE)
[17:29:42.451]                     NULL
[17:29:42.451]                   }
[17:29:42.451]                   options(future.plan = NULL)
[17:29:42.451]                   if (is.na(NA_character_)) 
[17:29:42.451]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.451]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.451]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.451]                     .init = FALSE)
[17:29:42.451]                 }
[17:29:42.451]             }
[17:29:42.451]         }
[17:29:42.451]     })
[17:29:42.451]     if (TRUE) {
[17:29:42.451]         base::sink(type = "output", split = FALSE)
[17:29:42.451]         if (TRUE) {
[17:29:42.451]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.451]         }
[17:29:42.451]         else {
[17:29:42.451]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.451]         }
[17:29:42.451]         base::close(...future.stdout)
[17:29:42.451]         ...future.stdout <- NULL
[17:29:42.451]     }
[17:29:42.451]     ...future.result$conditions <- ...future.conditions
[17:29:42.451]     ...future.result$finished <- base::Sys.time()
[17:29:42.451]     ...future.result
[17:29:42.451] }
[17:29:42.456] assign_globals() ...
[17:29:42.456] List of 1
[17:29:42.456]  $ x: int [1:4] 0 1 2 3
[17:29:42.456]  - attr(*, "where")=List of 1
[17:29:42.456]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.456]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.456]  - attr(*, "resolved")= logi FALSE
[17:29:42.456]  - attr(*, "total_size")= int 133
[17:29:42.456]  - attr(*, "already-done")= logi TRUE
[17:29:42.462] - copied 'x' to environment
[17:29:42.462] assign_globals() ... done
[17:29:42.463] plan(): Setting new future strategy stack:
[17:29:42.463] List of future strategies:
[17:29:42.463] 1. sequential:
[17:29:42.463]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.463]    - tweaked: FALSE
[17:29:42.463]    - call: NULL
[17:29:42.464] plan(): nbrOfWorkers() = 1
[17:29:42.467] plan(): Setting new future strategy stack:
[17:29:42.467] List of future strategies:
[17:29:42.467] 1. sequential:
[17:29:42.467]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.467]    - tweaked: FALSE
[17:29:42.467]    - call: plan(strategy)
[17:29:42.468] plan(): nbrOfWorkers() = 1
[17:29:42.469] SequentialFuture started (and completed)
[17:29:42.469] - Launch lazy future ... done
[17:29:42.470] run() for 'SequentialFuture' ... done
[17:29:42.471] getGlobalsAndPackages() ...
[17:29:42.471] Searching for globals...
[17:29:42.474] - globals found: [3] '{', 'sample', 'x'
[17:29:42.474] Searching for globals ... DONE
[17:29:42.475] Resolving globals: FALSE
[17:29:42.476] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.476] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.477] - globals: [1] 'x'
[17:29:42.477] 
[17:29:42.478] getGlobalsAndPackages() ... DONE
[17:29:42.478] run() for 'Future' ...
[17:29:42.479] - state: 'created'
[17:29:42.479] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.480] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.480] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.481]   - Field: 'label'
[17:29:42.481]   - Field: 'local'
[17:29:42.482]   - Field: 'owner'
[17:29:42.482]   - Field: 'envir'
[17:29:42.482]   - Field: 'packages'
[17:29:42.483]   - Field: 'gc'
[17:29:42.483]   - Field: 'conditions'
[17:29:42.484]   - Field: 'expr'
[17:29:42.484]   - Field: 'uuid'
[17:29:42.484]   - Field: 'seed'
[17:29:42.485]   - Field: 'version'
[17:29:42.485]   - Field: 'result'
[17:29:42.485]   - Field: 'asynchronous'
[17:29:42.486]   - Field: 'calls'
[17:29:42.486]   - Field: 'globals'
[17:29:42.487]   - Field: 'stdout'
[17:29:42.487]   - Field: 'earlySignal'
[17:29:42.488]   - Field: 'lazy'
[17:29:42.488]   - Field: 'state'
[17:29:42.488] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.489] - Launch lazy future ...
[17:29:42.489] Packages needed by the future expression (n = 0): <none>
[17:29:42.490] Packages needed by future strategies (n = 0): <none>
[17:29:42.491] {
[17:29:42.491]     {
[17:29:42.491]         {
[17:29:42.491]             ...future.startTime <- base::Sys.time()
[17:29:42.491]             {
[17:29:42.491]                 {
[17:29:42.491]                   {
[17:29:42.491]                     base::local({
[17:29:42.491]                       has_future <- base::requireNamespace("future", 
[17:29:42.491]                         quietly = TRUE)
[17:29:42.491]                       if (has_future) {
[17:29:42.491]                         ns <- base::getNamespace("future")
[17:29:42.491]                         version <- ns[[".package"]][["version"]]
[17:29:42.491]                         if (is.null(version)) 
[17:29:42.491]                           version <- utils::packageVersion("future")
[17:29:42.491]                       }
[17:29:42.491]                       else {
[17:29:42.491]                         version <- NULL
[17:29:42.491]                       }
[17:29:42.491]                       if (!has_future || version < "1.8.0") {
[17:29:42.491]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.491]                           "", base::R.version$version.string), 
[17:29:42.491]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.491]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.491]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.491]                             "release", "version")], collapse = " "), 
[17:29:42.491]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.491]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.491]                           info)
[17:29:42.491]                         info <- base::paste(info, collapse = "; ")
[17:29:42.491]                         if (!has_future) {
[17:29:42.491]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.491]                             info)
[17:29:42.491]                         }
[17:29:42.491]                         else {
[17:29:42.491]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.491]                             info, version)
[17:29:42.491]                         }
[17:29:42.491]                         base::stop(msg)
[17:29:42.491]                       }
[17:29:42.491]                     })
[17:29:42.491]                   }
[17:29:42.491]                   ...future.strategy.old <- future::plan("list")
[17:29:42.491]                   options(future.plan = NULL)
[17:29:42.491]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.491]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.491]                 }
[17:29:42.491]                 ...future.workdir <- getwd()
[17:29:42.491]             }
[17:29:42.491]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.491]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.491]         }
[17:29:42.491]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.491]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.491]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.491]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.491]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.491]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.491]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.491]             base::names(...future.oldOptions))
[17:29:42.491]     }
[17:29:42.491]     if (FALSE) {
[17:29:42.491]     }
[17:29:42.491]     else {
[17:29:42.491]         if (TRUE) {
[17:29:42.491]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.491]                 open = "w")
[17:29:42.491]         }
[17:29:42.491]         else {
[17:29:42.491]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.491]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.491]         }
[17:29:42.491]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.491]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.491]             base::sink(type = "output", split = FALSE)
[17:29:42.491]             base::close(...future.stdout)
[17:29:42.491]         }, add = TRUE)
[17:29:42.491]     }
[17:29:42.491]     ...future.frame <- base::sys.nframe()
[17:29:42.491]     ...future.conditions <- base::list()
[17:29:42.491]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.491]     if (FALSE) {
[17:29:42.491]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.491]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.491]     }
[17:29:42.491]     ...future.result <- base::tryCatch({
[17:29:42.491]         base::withCallingHandlers({
[17:29:42.491]             ...future.value <- base::withVisible(base::local({
[17:29:42.491]                 sample(x, size = 1L)
[17:29:42.491]             }))
[17:29:42.491]             future::FutureResult(value = ...future.value$value, 
[17:29:42.491]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.491]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.491]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.491]                     ...future.globalenv.names))
[17:29:42.491]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.491]         }, condition = base::local({
[17:29:42.491]             c <- base::c
[17:29:42.491]             inherits <- base::inherits
[17:29:42.491]             invokeRestart <- base::invokeRestart
[17:29:42.491]             length <- base::length
[17:29:42.491]             list <- base::list
[17:29:42.491]             seq.int <- base::seq.int
[17:29:42.491]             signalCondition <- base::signalCondition
[17:29:42.491]             sys.calls <- base::sys.calls
[17:29:42.491]             `[[` <- base::`[[`
[17:29:42.491]             `+` <- base::`+`
[17:29:42.491]             `<<-` <- base::`<<-`
[17:29:42.491]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.491]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.491]                   3L)]
[17:29:42.491]             }
[17:29:42.491]             function(cond) {
[17:29:42.491]                 is_error <- inherits(cond, "error")
[17:29:42.491]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.491]                   NULL)
[17:29:42.491]                 if (is_error) {
[17:29:42.491]                   sessionInformation <- function() {
[17:29:42.491]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.491]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.491]                       search = base::search(), system = base::Sys.info())
[17:29:42.491]                   }
[17:29:42.491]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.491]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.491]                     cond$call), session = sessionInformation(), 
[17:29:42.491]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.491]                   signalCondition(cond)
[17:29:42.491]                 }
[17:29:42.491]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.491]                 "immediateCondition"))) {
[17:29:42.491]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.491]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.491]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.491]                   if (TRUE && !signal) {
[17:29:42.491]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.491]                     {
[17:29:42.491]                       inherits <- base::inherits
[17:29:42.491]                       invokeRestart <- base::invokeRestart
[17:29:42.491]                       is.null <- base::is.null
[17:29:42.491]                       muffled <- FALSE
[17:29:42.491]                       if (inherits(cond, "message")) {
[17:29:42.491]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.491]                         if (muffled) 
[17:29:42.491]                           invokeRestart("muffleMessage")
[17:29:42.491]                       }
[17:29:42.491]                       else if (inherits(cond, "warning")) {
[17:29:42.491]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.491]                         if (muffled) 
[17:29:42.491]                           invokeRestart("muffleWarning")
[17:29:42.491]                       }
[17:29:42.491]                       else if (inherits(cond, "condition")) {
[17:29:42.491]                         if (!is.null(pattern)) {
[17:29:42.491]                           computeRestarts <- base::computeRestarts
[17:29:42.491]                           grepl <- base::grepl
[17:29:42.491]                           restarts <- computeRestarts(cond)
[17:29:42.491]                           for (restart in restarts) {
[17:29:42.491]                             name <- restart$name
[17:29:42.491]                             if (is.null(name)) 
[17:29:42.491]                               next
[17:29:42.491]                             if (!grepl(pattern, name)) 
[17:29:42.491]                               next
[17:29:42.491]                             invokeRestart(restart)
[17:29:42.491]                             muffled <- TRUE
[17:29:42.491]                             break
[17:29:42.491]                           }
[17:29:42.491]                         }
[17:29:42.491]                       }
[17:29:42.491]                       invisible(muffled)
[17:29:42.491]                     }
[17:29:42.491]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.491]                   }
[17:29:42.491]                 }
[17:29:42.491]                 else {
[17:29:42.491]                   if (TRUE) {
[17:29:42.491]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.491]                     {
[17:29:42.491]                       inherits <- base::inherits
[17:29:42.491]                       invokeRestart <- base::invokeRestart
[17:29:42.491]                       is.null <- base::is.null
[17:29:42.491]                       muffled <- FALSE
[17:29:42.491]                       if (inherits(cond, "message")) {
[17:29:42.491]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.491]                         if (muffled) 
[17:29:42.491]                           invokeRestart("muffleMessage")
[17:29:42.491]                       }
[17:29:42.491]                       else if (inherits(cond, "warning")) {
[17:29:42.491]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.491]                         if (muffled) 
[17:29:42.491]                           invokeRestart("muffleWarning")
[17:29:42.491]                       }
[17:29:42.491]                       else if (inherits(cond, "condition")) {
[17:29:42.491]                         if (!is.null(pattern)) {
[17:29:42.491]                           computeRestarts <- base::computeRestarts
[17:29:42.491]                           grepl <- base::grepl
[17:29:42.491]                           restarts <- computeRestarts(cond)
[17:29:42.491]                           for (restart in restarts) {
[17:29:42.491]                             name <- restart$name
[17:29:42.491]                             if (is.null(name)) 
[17:29:42.491]                               next
[17:29:42.491]                             if (!grepl(pattern, name)) 
[17:29:42.491]                               next
[17:29:42.491]                             invokeRestart(restart)
[17:29:42.491]                             muffled <- TRUE
[17:29:42.491]                             break
[17:29:42.491]                           }
[17:29:42.491]                         }
[17:29:42.491]                       }
[17:29:42.491]                       invisible(muffled)
[17:29:42.491]                     }
[17:29:42.491]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.491]                   }
[17:29:42.491]                 }
[17:29:42.491]             }
[17:29:42.491]         }))
[17:29:42.491]     }, error = function(ex) {
[17:29:42.491]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.491]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.491]                 ...future.rng), started = ...future.startTime, 
[17:29:42.491]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.491]             version = "1.8"), class = "FutureResult")
[17:29:42.491]     }, finally = {
[17:29:42.491]         if (!identical(...future.workdir, getwd())) 
[17:29:42.491]             setwd(...future.workdir)
[17:29:42.491]         {
[17:29:42.491]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.491]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.491]             }
[17:29:42.491]             base::options(...future.oldOptions)
[17:29:42.491]             if (.Platform$OS.type == "windows") {
[17:29:42.491]                 old_names <- names(...future.oldEnvVars)
[17:29:42.491]                 envs <- base::Sys.getenv()
[17:29:42.491]                 names <- names(envs)
[17:29:42.491]                 common <- intersect(names, old_names)
[17:29:42.491]                 added <- setdiff(names, old_names)
[17:29:42.491]                 removed <- setdiff(old_names, names)
[17:29:42.491]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.491]                   envs[common]]
[17:29:42.491]                 NAMES <- toupper(changed)
[17:29:42.491]                 args <- list()
[17:29:42.491]                 for (kk in seq_along(NAMES)) {
[17:29:42.491]                   name <- changed[[kk]]
[17:29:42.491]                   NAME <- NAMES[[kk]]
[17:29:42.491]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.491]                     next
[17:29:42.491]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.491]                 }
[17:29:42.491]                 NAMES <- toupper(added)
[17:29:42.491]                 for (kk in seq_along(NAMES)) {
[17:29:42.491]                   name <- added[[kk]]
[17:29:42.491]                   NAME <- NAMES[[kk]]
[17:29:42.491]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.491]                     next
[17:29:42.491]                   args[[name]] <- ""
[17:29:42.491]                 }
[17:29:42.491]                 NAMES <- toupper(removed)
[17:29:42.491]                 for (kk in seq_along(NAMES)) {
[17:29:42.491]                   name <- removed[[kk]]
[17:29:42.491]                   NAME <- NAMES[[kk]]
[17:29:42.491]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.491]                     next
[17:29:42.491]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.491]                 }
[17:29:42.491]                 if (length(args) > 0) 
[17:29:42.491]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.491]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.491]             }
[17:29:42.491]             else {
[17:29:42.491]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.491]             }
[17:29:42.491]             {
[17:29:42.491]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.491]                   0L) {
[17:29:42.491]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.491]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.491]                   base::options(opts)
[17:29:42.491]                 }
[17:29:42.491]                 {
[17:29:42.491]                   {
[17:29:42.491]                     base::assign(".Random.seed", c(10407L, -252299846L, 
[17:29:42.491]                     1961593306L, -1257450365L, -1585431857L, 
[17:29:42.491]                     1137698484L, 1475741235L), envir = base::globalenv(), 
[17:29:42.491]                       inherits = FALSE)
[17:29:42.491]                     NULL
[17:29:42.491]                   }
[17:29:42.491]                   options(future.plan = NULL)
[17:29:42.491]                   if (is.na(NA_character_)) 
[17:29:42.491]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.491]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.491]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.491]                     .init = FALSE)
[17:29:42.491]                 }
[17:29:42.491]             }
[17:29:42.491]         }
[17:29:42.491]     })
[17:29:42.491]     if (TRUE) {
[17:29:42.491]         base::sink(type = "output", split = FALSE)
[17:29:42.491]         if (TRUE) {
[17:29:42.491]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.491]         }
[17:29:42.491]         else {
[17:29:42.491]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.491]         }
[17:29:42.491]         base::close(...future.stdout)
[17:29:42.491]         ...future.stdout <- NULL
[17:29:42.491]     }
[17:29:42.491]     ...future.result$conditions <- ...future.conditions
[17:29:42.491]     ...future.result$finished <- base::Sys.time()
[17:29:42.491]     ...future.result
[17:29:42.491] }
[17:29:42.498] assign_globals() ...
[17:29:42.498] List of 1
[17:29:42.498]  $ x: int [1:4] 0 1 2 3
[17:29:42.498]  - attr(*, "where")=List of 1
[17:29:42.498]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.498]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.498]  - attr(*, "resolved")= logi FALSE
[17:29:42.498]  - attr(*, "total_size")= int 133
[17:29:42.498]  - attr(*, "already-done")= logi TRUE
[17:29:42.508] - copied 'x' to environment
[17:29:42.508] assign_globals() ... done
[17:29:42.509] plan(): Setting new future strategy stack:
[17:29:42.509] List of future strategies:
[17:29:42.509] 1. sequential:
[17:29:42.509]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.509]    - tweaked: FALSE
[17:29:42.509]    - call: NULL
[17:29:42.510] plan(): nbrOfWorkers() = 1
[17:29:42.512] plan(): Setting new future strategy stack:
[17:29:42.513] List of future strategies:
[17:29:42.513] 1. sequential:
[17:29:42.513]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.513]    - tweaked: FALSE
[17:29:42.513]    - call: plan(strategy)
[17:29:42.514] plan(): nbrOfWorkers() = 1
[17:29:42.515] SequentialFuture started (and completed)
[17:29:42.515] - Launch lazy future ... done
[17:29:42.515] run() for 'SequentialFuture' ... done
[17:29:42.516] Future state: 'finished'
[17:29:42.517] signalConditions() ...
[17:29:42.517]  - include = 'condition'
[17:29:42.517]  - exclude = 'immediateCondition'
[17:29:42.518]  - resignal = TRUE
[17:29:42.518]  - Number of conditions: 1
[17:29:42.519]  - Condition #1: 'RngFutureWarning', 'FutureWarning', 'warning', 'RngFutureCondition', 'FutureCondition', 'condition'
[17:29:42.519] signalConditions() ... done
<RngFutureWarning: UNRELIABLE VALUE: Future ('fsample_1-757701') 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: b6479779-97ab-114e-cdfb-36da4ae76b43


DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
SequentialFuture:
Label: 'fsample_1-757701'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add579f108
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Conditions captured: [n=1] 'RngFutureWarning'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'

DEBUG: END TROUBLESHOOTING HELP
[17:29:42.522] getGlobalsAndPackages() ...
[17:29:42.522] Searching for globals...
[17:29:42.524] - globals found: [3] '{', 'sample', 'x'
[17:29:42.525] Searching for globals ... DONE
[17:29:42.525] Resolving globals: FALSE
[17:29:42.526] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.526] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.527] - globals: [1] 'x'
[17:29:42.527] 
[17:29:42.527] getGlobalsAndPackages() ... DONE
[17:29:42.528] run() for 'Future' ...
[17:29:42.528] - state: 'created'
[17:29:42.529] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.530] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.530] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.530]   - Field: 'label'
[17:29:42.531]   - Field: 'local'
[17:29:42.531]   - Field: 'owner'
[17:29:42.531]   - Field: 'envir'
[17:29:42.532]   - Field: 'packages'
[17:29:42.532]   - Field: 'gc'
[17:29:42.533]   - Field: 'conditions'
[17:29:42.533]   - Field: 'expr'
[17:29:42.533]   - Field: 'uuid'
[17:29:42.534]   - Field: 'seed'
[17:29:42.534]   - Field: 'version'
[17:29:42.534]   - Field: 'result'
[17:29:42.535]   - Field: 'asynchronous'
[17:29:42.535]   - Field: 'calls'
[17:29:42.535]   - Field: 'globals'
[17:29:42.536]   - Field: 'stdout'
[17:29:42.536]   - Field: 'earlySignal'
[17:29:42.536]   - Field: 'lazy'
[17:29:42.537]   - Field: 'state'
[17:29:42.537] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.537] - Launch lazy future ...
[17:29:42.538] Packages needed by the future expression (n = 0): <none>
[17:29:42.538] Packages needed by future strategies (n = 0): <none>
[17:29:42.539] {
[17:29:42.539]     {
[17:29:42.539]         {
[17:29:42.539]             ...future.startTime <- base::Sys.time()
[17:29:42.539]             {
[17:29:42.539]                 {
[17:29:42.539]                   {
[17:29:42.539]                     base::local({
[17:29:42.539]                       has_future <- base::requireNamespace("future", 
[17:29:42.539]                         quietly = TRUE)
[17:29:42.539]                       if (has_future) {
[17:29:42.539]                         ns <- base::getNamespace("future")
[17:29:42.539]                         version <- ns[[".package"]][["version"]]
[17:29:42.539]                         if (is.null(version)) 
[17:29:42.539]                           version <- utils::packageVersion("future")
[17:29:42.539]                       }
[17:29:42.539]                       else {
[17:29:42.539]                         version <- NULL
[17:29:42.539]                       }
[17:29:42.539]                       if (!has_future || version < "1.8.0") {
[17:29:42.539]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.539]                           "", base::R.version$version.string), 
[17:29:42.539]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.539]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.539]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.539]                             "release", "version")], collapse = " "), 
[17:29:42.539]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.539]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.539]                           info)
[17:29:42.539]                         info <- base::paste(info, collapse = "; ")
[17:29:42.539]                         if (!has_future) {
[17:29:42.539]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.539]                             info)
[17:29:42.539]                         }
[17:29:42.539]                         else {
[17:29:42.539]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.539]                             info, version)
[17:29:42.539]                         }
[17:29:42.539]                         base::stop(msg)
[17:29:42.539]                       }
[17:29:42.539]                     })
[17:29:42.539]                   }
[17:29:42.539]                   ...future.strategy.old <- future::plan("list")
[17:29:42.539]                   options(future.plan = NULL)
[17:29:42.539]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.539]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.539]                 }
[17:29:42.539]                 ...future.workdir <- getwd()
[17:29:42.539]             }
[17:29:42.539]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.539]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.539]         }
[17:29:42.539]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.539]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.539]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.539]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.539]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.539]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.539]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.539]             base::names(...future.oldOptions))
[17:29:42.539]     }
[17:29:42.539]     if (FALSE) {
[17:29:42.539]     }
[17:29:42.539]     else {
[17:29:42.539]         if (TRUE) {
[17:29:42.539]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.539]                 open = "w")
[17:29:42.539]         }
[17:29:42.539]         else {
[17:29:42.539]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.539]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.539]         }
[17:29:42.539]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.539]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.539]             base::sink(type = "output", split = FALSE)
[17:29:42.539]             base::close(...future.stdout)
[17:29:42.539]         }, add = TRUE)
[17:29:42.539]     }
[17:29:42.539]     ...future.frame <- base::sys.nframe()
[17:29:42.539]     ...future.conditions <- base::list()
[17:29:42.539]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.539]     if (FALSE) {
[17:29:42.539]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.539]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.539]     }
[17:29:42.539]     ...future.result <- base::tryCatch({
[17:29:42.539]         base::withCallingHandlers({
[17:29:42.539]             ...future.value <- base::withVisible(base::local({
[17:29:42.539]                 sample(x, size = 1L)
[17:29:42.539]             }))
[17:29:42.539]             future::FutureResult(value = ...future.value$value, 
[17:29:42.539]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.539]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.539]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.539]                     ...future.globalenv.names))
[17:29:42.539]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.539]         }, condition = base::local({
[17:29:42.539]             c <- base::c
[17:29:42.539]             inherits <- base::inherits
[17:29:42.539]             invokeRestart <- base::invokeRestart
[17:29:42.539]             length <- base::length
[17:29:42.539]             list <- base::list
[17:29:42.539]             seq.int <- base::seq.int
[17:29:42.539]             signalCondition <- base::signalCondition
[17:29:42.539]             sys.calls <- base::sys.calls
[17:29:42.539]             `[[` <- base::`[[`
[17:29:42.539]             `+` <- base::`+`
[17:29:42.539]             `<<-` <- base::`<<-`
[17:29:42.539]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.539]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.539]                   3L)]
[17:29:42.539]             }
[17:29:42.539]             function(cond) {
[17:29:42.539]                 is_error <- inherits(cond, "error")
[17:29:42.539]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.539]                   NULL)
[17:29:42.539]                 if (is_error) {
[17:29:42.539]                   sessionInformation <- function() {
[17:29:42.539]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.539]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.539]                       search = base::search(), system = base::Sys.info())
[17:29:42.539]                   }
[17:29:42.539]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.539]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.539]                     cond$call), session = sessionInformation(), 
[17:29:42.539]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.539]                   signalCondition(cond)
[17:29:42.539]                 }
[17:29:42.539]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.539]                 "immediateCondition"))) {
[17:29:42.539]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.539]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.539]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.539]                   if (TRUE && !signal) {
[17:29:42.539]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.539]                     {
[17:29:42.539]                       inherits <- base::inherits
[17:29:42.539]                       invokeRestart <- base::invokeRestart
[17:29:42.539]                       is.null <- base::is.null
[17:29:42.539]                       muffled <- FALSE
[17:29:42.539]                       if (inherits(cond, "message")) {
[17:29:42.539]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.539]                         if (muffled) 
[17:29:42.539]                           invokeRestart("muffleMessage")
[17:29:42.539]                       }
[17:29:42.539]                       else if (inherits(cond, "warning")) {
[17:29:42.539]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.539]                         if (muffled) 
[17:29:42.539]                           invokeRestart("muffleWarning")
[17:29:42.539]                       }
[17:29:42.539]                       else if (inherits(cond, "condition")) {
[17:29:42.539]                         if (!is.null(pattern)) {
[17:29:42.539]                           computeRestarts <- base::computeRestarts
[17:29:42.539]                           grepl <- base::grepl
[17:29:42.539]                           restarts <- computeRestarts(cond)
[17:29:42.539]                           for (restart in restarts) {
[17:29:42.539]                             name <- restart$name
[17:29:42.539]                             if (is.null(name)) 
[17:29:42.539]                               next
[17:29:42.539]                             if (!grepl(pattern, name)) 
[17:29:42.539]                               next
[17:29:42.539]                             invokeRestart(restart)
[17:29:42.539]                             muffled <- TRUE
[17:29:42.539]                             break
[17:29:42.539]                           }
[17:29:42.539]                         }
[17:29:42.539]                       }
[17:29:42.539]                       invisible(muffled)
[17:29:42.539]                     }
[17:29:42.539]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.539]                   }
[17:29:42.539]                 }
[17:29:42.539]                 else {
[17:29:42.539]                   if (TRUE) {
[17:29:42.539]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.539]                     {
[17:29:42.539]                       inherits <- base::inherits
[17:29:42.539]                       invokeRestart <- base::invokeRestart
[17:29:42.539]                       is.null <- base::is.null
[17:29:42.539]                       muffled <- FALSE
[17:29:42.539]                       if (inherits(cond, "message")) {
[17:29:42.539]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.539]                         if (muffled) 
[17:29:42.539]                           invokeRestart("muffleMessage")
[17:29:42.539]                       }
[17:29:42.539]                       else if (inherits(cond, "warning")) {
[17:29:42.539]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.539]                         if (muffled) 
[17:29:42.539]                           invokeRestart("muffleWarning")
[17:29:42.539]                       }
[17:29:42.539]                       else if (inherits(cond, "condition")) {
[17:29:42.539]                         if (!is.null(pattern)) {
[17:29:42.539]                           computeRestarts <- base::computeRestarts
[17:29:42.539]                           grepl <- base::grepl
[17:29:42.539]                           restarts <- computeRestarts(cond)
[17:29:42.539]                           for (restart in restarts) {
[17:29:42.539]                             name <- restart$name
[17:29:42.539]                             if (is.null(name)) 
[17:29:42.539]                               next
[17:29:42.539]                             if (!grepl(pattern, name)) 
[17:29:42.539]                               next
[17:29:42.539]                             invokeRestart(restart)
[17:29:42.539]                             muffled <- TRUE
[17:29:42.539]                             break
[17:29:42.539]                           }
[17:29:42.539]                         }
[17:29:42.539]                       }
[17:29:42.539]                       invisible(muffled)
[17:29:42.539]                     }
[17:29:42.539]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.539]                   }
[17:29:42.539]                 }
[17:29:42.539]             }
[17:29:42.539]         }))
[17:29:42.539]     }, error = function(ex) {
[17:29:42.539]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.539]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.539]                 ...future.rng), started = ...future.startTime, 
[17:29:42.539]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.539]             version = "1.8"), class = "FutureResult")
[17:29:42.539]     }, finally = {
[17:29:42.539]         if (!identical(...future.workdir, getwd())) 
[17:29:42.539]             setwd(...future.workdir)
[17:29:42.539]         {
[17:29:42.539]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.539]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.539]             }
[17:29:42.539]             base::options(...future.oldOptions)
[17:29:42.539]             if (.Platform$OS.type == "windows") {
[17:29:42.539]                 old_names <- names(...future.oldEnvVars)
[17:29:42.539]                 envs <- base::Sys.getenv()
[17:29:42.539]                 names <- names(envs)
[17:29:42.539]                 common <- intersect(names, old_names)
[17:29:42.539]                 added <- setdiff(names, old_names)
[17:29:42.539]                 removed <- setdiff(old_names, names)
[17:29:42.539]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.539]                   envs[common]]
[17:29:42.539]                 NAMES <- toupper(changed)
[17:29:42.539]                 args <- list()
[17:29:42.539]                 for (kk in seq_along(NAMES)) {
[17:29:42.539]                   name <- changed[[kk]]
[17:29:42.539]                   NAME <- NAMES[[kk]]
[17:29:42.539]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.539]                     next
[17:29:42.539]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.539]                 }
[17:29:42.539]                 NAMES <- toupper(added)
[17:29:42.539]                 for (kk in seq_along(NAMES)) {
[17:29:42.539]                   name <- added[[kk]]
[17:29:42.539]                   NAME <- NAMES[[kk]]
[17:29:42.539]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.539]                     next
[17:29:42.539]                   args[[name]] <- ""
[17:29:42.539]                 }
[17:29:42.539]                 NAMES <- toupper(removed)
[17:29:42.539]                 for (kk in seq_along(NAMES)) {
[17:29:42.539]                   name <- removed[[kk]]
[17:29:42.539]                   NAME <- NAMES[[kk]]
[17:29:42.539]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.539]                     next
[17:29:42.539]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.539]                 }
[17:29:42.539]                 if (length(args) > 0) 
[17:29:42.539]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.539]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.539]             }
[17:29:42.539]             else {
[17:29:42.539]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.539]             }
[17:29:42.539]             {
[17:29:42.539]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.539]                   0L) {
[17:29:42.539]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.539]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.539]                   base::options(opts)
[17:29:42.539]                 }
[17:29:42.539]                 {
[17:29:42.539]                   {
[17:29:42.539]                     base::assign(".Random.seed", c(10407L, -1950082174L, 
[17:29:42.539]                     -1301753524L, -1463922712L, 943607073L, 1021273868L, 
[17:29:42.539]                     -265366594L), envir = base::globalenv(), 
[17:29:42.539]                       inherits = FALSE)
[17:29:42.539]                     NULL
[17:29:42.539]                   }
[17:29:42.539]                   options(future.plan = NULL)
[17:29:42.539]                   if (is.na(NA_character_)) 
[17:29:42.539]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.539]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.539]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.539]                     .init = FALSE)
[17:29:42.539]                 }
[17:29:42.539]             }
[17:29:42.539]         }
[17:29:42.539]     })
[17:29:42.539]     if (TRUE) {
[17:29:42.539]         base::sink(type = "output", split = FALSE)
[17:29:42.539]         if (TRUE) {
[17:29:42.539]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.539]         }
[17:29:42.539]         else {
[17:29:42.539]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.539]         }
[17:29:42.539]         base::close(...future.stdout)
[17:29:42.539]         ...future.stdout <- NULL
[17:29:42.539]     }
[17:29:42.539]     ...future.result$conditions <- ...future.conditions
[17:29:42.539]     ...future.result$finished <- base::Sys.time()
[17:29:42.539]     ...future.result
[17:29:42.539] }
[17:29:42.544] assign_globals() ...
[17:29:42.544] List of 1
[17:29:42.544]  $ x: int [1:4] 0 1 2 3
[17:29:42.544]  - attr(*, "where")=List of 1
[17:29:42.544]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.544]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.544]  - attr(*, "resolved")= logi FALSE
[17:29:42.544]  - attr(*, "total_size")= int 133
[17:29:42.544]  - attr(*, "already-done")= logi TRUE
[17:29:42.549] - copied 'x' to environment
[17:29:42.549] assign_globals() ... done
[17:29:42.550] plan(): Setting new future strategy stack:
[17:29:42.550] List of future strategies:
[17:29:42.550] 1. sequential:
[17:29:42.550]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.550]    - tweaked: FALSE
[17:29:42.550]    - call: NULL
[17:29:42.551] plan(): nbrOfWorkers() = 1
[17:29:42.553] plan(): Setting new future strategy stack:
[17:29:42.553] List of future strategies:
[17:29:42.553] 1. sequential:
[17:29:42.553]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.553]    - tweaked: FALSE
[17:29:42.553]    - call: plan(strategy)
[17:29:42.557] plan(): nbrOfWorkers() = 1
[17:29:42.558] SequentialFuture started (and completed)
[17:29:42.558] - Launch lazy future ... done
[17:29:42.558] run() for 'SequentialFuture' ... done
[17:29:42.559] getGlobalsAndPackages() ...
[17:29:42.559] Searching for globals...
[17:29:42.561] - globals found: [3] '{', 'sample', 'x'
[17:29:42.561] Searching for globals ... DONE
[17:29:42.561] Resolving globals: FALSE
[17:29:42.562] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.562] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.563] - globals: [1] 'x'
[17:29:42.563] 
[17:29:42.563] getGlobalsAndPackages() ... DONE
[17:29:42.563] run() for 'Future' ...
[17:29:42.564] - state: 'created'
[17:29:42.564] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.564] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.565] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.565]   - Field: 'label'
[17:29:42.565]   - Field: 'local'
[17:29:42.565]   - Field: 'owner'
[17:29:42.565]   - Field: 'envir'
[17:29:42.566]   - Field: 'packages'
[17:29:42.566]   - Field: 'gc'
[17:29:42.566]   - Field: 'conditions'
[17:29:42.566]   - Field: 'expr'
[17:29:42.566]   - Field: 'uuid'
[17:29:42.567]   - Field: 'seed'
[17:29:42.567]   - Field: 'version'
[17:29:42.567]   - Field: 'result'
[17:29:42.567]   - Field: 'asynchronous'
[17:29:42.567]   - Field: 'calls'
[17:29:42.567]   - Field: 'globals'
[17:29:42.568]   - Field: 'stdout'
[17:29:42.568]   - Field: 'earlySignal'
[17:29:42.568]   - Field: 'lazy'
[17:29:42.568]   - Field: 'state'
[17:29:42.568] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.568] - Launch lazy future ...
[17:29:42.569] Packages needed by the future expression (n = 0): <none>
[17:29:42.569] Packages needed by future strategies (n = 0): <none>
[17:29:42.570] {
[17:29:42.570]     {
[17:29:42.570]         {
[17:29:42.570]             ...future.startTime <- base::Sys.time()
[17:29:42.570]             {
[17:29:42.570]                 {
[17:29:42.570]                   {
[17:29:42.570]                     base::local({
[17:29:42.570]                       has_future <- base::requireNamespace("future", 
[17:29:42.570]                         quietly = TRUE)
[17:29:42.570]                       if (has_future) {
[17:29:42.570]                         ns <- base::getNamespace("future")
[17:29:42.570]                         version <- ns[[".package"]][["version"]]
[17:29:42.570]                         if (is.null(version)) 
[17:29:42.570]                           version <- utils::packageVersion("future")
[17:29:42.570]                       }
[17:29:42.570]                       else {
[17:29:42.570]                         version <- NULL
[17:29:42.570]                       }
[17:29:42.570]                       if (!has_future || version < "1.8.0") {
[17:29:42.570]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.570]                           "", base::R.version$version.string), 
[17:29:42.570]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.570]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.570]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.570]                             "release", "version")], collapse = " "), 
[17:29:42.570]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.570]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.570]                           info)
[17:29:42.570]                         info <- base::paste(info, collapse = "; ")
[17:29:42.570]                         if (!has_future) {
[17:29:42.570]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.570]                             info)
[17:29:42.570]                         }
[17:29:42.570]                         else {
[17:29:42.570]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.570]                             info, version)
[17:29:42.570]                         }
[17:29:42.570]                         base::stop(msg)
[17:29:42.570]                       }
[17:29:42.570]                     })
[17:29:42.570]                   }
[17:29:42.570]                   ...future.strategy.old <- future::plan("list")
[17:29:42.570]                   options(future.plan = NULL)
[17:29:42.570]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.570]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.570]                 }
[17:29:42.570]                 ...future.workdir <- getwd()
[17:29:42.570]             }
[17:29:42.570]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.570]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.570]         }
[17:29:42.570]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.570]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.570]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.570]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.570]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.570]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.570]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.570]             base::names(...future.oldOptions))
[17:29:42.570]     }
[17:29:42.570]     if (FALSE) {
[17:29:42.570]     }
[17:29:42.570]     else {
[17:29:42.570]         if (TRUE) {
[17:29:42.570]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.570]                 open = "w")
[17:29:42.570]         }
[17:29:42.570]         else {
[17:29:42.570]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.570]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.570]         }
[17:29:42.570]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.570]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.570]             base::sink(type = "output", split = FALSE)
[17:29:42.570]             base::close(...future.stdout)
[17:29:42.570]         }, add = TRUE)
[17:29:42.570]     }
[17:29:42.570]     ...future.frame <- base::sys.nframe()
[17:29:42.570]     ...future.conditions <- base::list()
[17:29:42.570]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.570]     if (FALSE) {
[17:29:42.570]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.570]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.570]     }
[17:29:42.570]     ...future.result <- base::tryCatch({
[17:29:42.570]         base::withCallingHandlers({
[17:29:42.570]             ...future.value <- base::withVisible(base::local({
[17:29:42.570]                 sample(x, size = 1L)
[17:29:42.570]             }))
[17:29:42.570]             future::FutureResult(value = ...future.value$value, 
[17:29:42.570]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.570]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.570]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.570]                     ...future.globalenv.names))
[17:29:42.570]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.570]         }, condition = base::local({
[17:29:42.570]             c <- base::c
[17:29:42.570]             inherits <- base::inherits
[17:29:42.570]             invokeRestart <- base::invokeRestart
[17:29:42.570]             length <- base::length
[17:29:42.570]             list <- base::list
[17:29:42.570]             seq.int <- base::seq.int
[17:29:42.570]             signalCondition <- base::signalCondition
[17:29:42.570]             sys.calls <- base::sys.calls
[17:29:42.570]             `[[` <- base::`[[`
[17:29:42.570]             `+` <- base::`+`
[17:29:42.570]             `<<-` <- base::`<<-`
[17:29:42.570]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.570]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.570]                   3L)]
[17:29:42.570]             }
[17:29:42.570]             function(cond) {
[17:29:42.570]                 is_error <- inherits(cond, "error")
[17:29:42.570]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.570]                   NULL)
[17:29:42.570]                 if (is_error) {
[17:29:42.570]                   sessionInformation <- function() {
[17:29:42.570]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.570]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.570]                       search = base::search(), system = base::Sys.info())
[17:29:42.570]                   }
[17:29:42.570]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.570]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.570]                     cond$call), session = sessionInformation(), 
[17:29:42.570]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.570]                   signalCondition(cond)
[17:29:42.570]                 }
[17:29:42.570]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.570]                 "immediateCondition"))) {
[17:29:42.570]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.570]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.570]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.570]                   if (TRUE && !signal) {
[17:29:42.570]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.570]                     {
[17:29:42.570]                       inherits <- base::inherits
[17:29:42.570]                       invokeRestart <- base::invokeRestart
[17:29:42.570]                       is.null <- base::is.null
[17:29:42.570]                       muffled <- FALSE
[17:29:42.570]                       if (inherits(cond, "message")) {
[17:29:42.570]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.570]                         if (muffled) 
[17:29:42.570]                           invokeRestart("muffleMessage")
[17:29:42.570]                       }
[17:29:42.570]                       else if (inherits(cond, "warning")) {
[17:29:42.570]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.570]                         if (muffled) 
[17:29:42.570]                           invokeRestart("muffleWarning")
[17:29:42.570]                       }
[17:29:42.570]                       else if (inherits(cond, "condition")) {
[17:29:42.570]                         if (!is.null(pattern)) {
[17:29:42.570]                           computeRestarts <- base::computeRestarts
[17:29:42.570]                           grepl <- base::grepl
[17:29:42.570]                           restarts <- computeRestarts(cond)
[17:29:42.570]                           for (restart in restarts) {
[17:29:42.570]                             name <- restart$name
[17:29:42.570]                             if (is.null(name)) 
[17:29:42.570]                               next
[17:29:42.570]                             if (!grepl(pattern, name)) 
[17:29:42.570]                               next
[17:29:42.570]                             invokeRestart(restart)
[17:29:42.570]                             muffled <- TRUE
[17:29:42.570]                             break
[17:29:42.570]                           }
[17:29:42.570]                         }
[17:29:42.570]                       }
[17:29:42.570]                       invisible(muffled)
[17:29:42.570]                     }
[17:29:42.570]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.570]                   }
[17:29:42.570]                 }
[17:29:42.570]                 else {
[17:29:42.570]                   if (TRUE) {
[17:29:42.570]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.570]                     {
[17:29:42.570]                       inherits <- base::inherits
[17:29:42.570]                       invokeRestart <- base::invokeRestart
[17:29:42.570]                       is.null <- base::is.null
[17:29:42.570]                       muffled <- FALSE
[17:29:42.570]                       if (inherits(cond, "message")) {
[17:29:42.570]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.570]                         if (muffled) 
[17:29:42.570]                           invokeRestart("muffleMessage")
[17:29:42.570]                       }
[17:29:42.570]                       else if (inherits(cond, "warning")) {
[17:29:42.570]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.570]                         if (muffled) 
[17:29:42.570]                           invokeRestart("muffleWarning")
[17:29:42.570]                       }
[17:29:42.570]                       else if (inherits(cond, "condition")) {
[17:29:42.570]                         if (!is.null(pattern)) {
[17:29:42.570]                           computeRestarts <- base::computeRestarts
[17:29:42.570]                           grepl <- base::grepl
[17:29:42.570]                           restarts <- computeRestarts(cond)
[17:29:42.570]                           for (restart in restarts) {
[17:29:42.570]                             name <- restart$name
[17:29:42.570]                             if (is.null(name)) 
[17:29:42.570]                               next
[17:29:42.570]                             if (!grepl(pattern, name)) 
[17:29:42.570]                               next
[17:29:42.570]                             invokeRestart(restart)
[17:29:42.570]                             muffled <- TRUE
[17:29:42.570]                             break
[17:29:42.570]                           }
[17:29:42.570]                         }
[17:29:42.570]                       }
[17:29:42.570]                       invisible(muffled)
[17:29:42.570]                     }
[17:29:42.570]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.570]                   }
[17:29:42.570]                 }
[17:29:42.570]             }
[17:29:42.570]         }))
[17:29:42.570]     }, error = function(ex) {
[17:29:42.570]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.570]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.570]                 ...future.rng), started = ...future.startTime, 
[17:29:42.570]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.570]             version = "1.8"), class = "FutureResult")
[17:29:42.570]     }, finally = {
[17:29:42.570]         if (!identical(...future.workdir, getwd())) 
[17:29:42.570]             setwd(...future.workdir)
[17:29:42.570]         {
[17:29:42.570]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.570]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.570]             }
[17:29:42.570]             base::options(...future.oldOptions)
[17:29:42.570]             if (.Platform$OS.type == "windows") {
[17:29:42.570]                 old_names <- names(...future.oldEnvVars)
[17:29:42.570]                 envs <- base::Sys.getenv()
[17:29:42.570]                 names <- names(envs)
[17:29:42.570]                 common <- intersect(names, old_names)
[17:29:42.570]                 added <- setdiff(names, old_names)
[17:29:42.570]                 removed <- setdiff(old_names, names)
[17:29:42.570]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.570]                   envs[common]]
[17:29:42.570]                 NAMES <- toupper(changed)
[17:29:42.570]                 args <- list()
[17:29:42.570]                 for (kk in seq_along(NAMES)) {
[17:29:42.570]                   name <- changed[[kk]]
[17:29:42.570]                   NAME <- NAMES[[kk]]
[17:29:42.570]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.570]                     next
[17:29:42.570]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.570]                 }
[17:29:42.570]                 NAMES <- toupper(added)
[17:29:42.570]                 for (kk in seq_along(NAMES)) {
[17:29:42.570]                   name <- added[[kk]]
[17:29:42.570]                   NAME <- NAMES[[kk]]
[17:29:42.570]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.570]                     next
[17:29:42.570]                   args[[name]] <- ""
[17:29:42.570]                 }
[17:29:42.570]                 NAMES <- toupper(removed)
[17:29:42.570]                 for (kk in seq_along(NAMES)) {
[17:29:42.570]                   name <- removed[[kk]]
[17:29:42.570]                   NAME <- NAMES[[kk]]
[17:29:42.570]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.570]                     next
[17:29:42.570]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.570]                 }
[17:29:42.570]                 if (length(args) > 0) 
[17:29:42.570]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.570]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.570]             }
[17:29:42.570]             else {
[17:29:42.570]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.570]             }
[17:29:42.570]             {
[17:29:42.570]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.570]                   0L) {
[17:29:42.570]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.570]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.570]                   base::options(opts)
[17:29:42.570]                 }
[17:29:42.570]                 {
[17:29:42.570]                   {
[17:29:42.570]                     base::assign(".Random.seed", c(10407L, -1463922712L, 
[17:29:42.570]                     -1482659767L, 1341507001L, -265366594L, -41790711L, 
[17:29:42.570]                     1571014043L), envir = base::globalenv(), 
[17:29:42.570]                       inherits = FALSE)
[17:29:42.570]                     NULL
[17:29:42.570]                   }
[17:29:42.570]                   options(future.plan = NULL)
[17:29:42.570]                   if (is.na(NA_character_)) 
[17:29:42.570]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.570]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.570]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.570]                     .init = FALSE)
[17:29:42.570]                 }
[17:29:42.570]             }
[17:29:42.570]         }
[17:29:42.570]     })
[17:29:42.570]     if (TRUE) {
[17:29:42.570]         base::sink(type = "output", split = FALSE)
[17:29:42.570]         if (TRUE) {
[17:29:42.570]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.570]         }
[17:29:42.570]         else {
[17:29:42.570]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.570]         }
[17:29:42.570]         base::close(...future.stdout)
[17:29:42.570]         ...future.stdout <- NULL
[17:29:42.570]     }
[17:29:42.570]     ...future.result$conditions <- ...future.conditions
[17:29:42.570]     ...future.result$finished <- base::Sys.time()
[17:29:42.570]     ...future.result
[17:29:42.570] }
[17:29:42.573] assign_globals() ...
[17:29:42.574] List of 1
[17:29:42.574]  $ x: int [1:4] 0 1 2 3
[17:29:42.574]  - attr(*, "where")=List of 1
[17:29:42.574]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.574]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.574]  - attr(*, "resolved")= logi FALSE
[17:29:42.574]  - attr(*, "total_size")= int 133
[17:29:42.574]  - attr(*, "already-done")= logi TRUE
[17:29:42.577] - copied 'x' to environment
[17:29:42.577] assign_globals() ... done
[17:29:42.577] plan(): Setting new future strategy stack:
[17:29:42.577] List of future strategies:
[17:29:42.577] 1. sequential:
[17:29:42.577]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.577]    - tweaked: FALSE
[17:29:42.577]    - call: NULL
[17:29:42.578] plan(): nbrOfWorkers() = 1
[17:29:42.579] plan(): Setting new future strategy stack:
[17:29:42.580] List of future strategies:
[17:29:42.580] 1. sequential:
[17:29:42.580]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.580]    - tweaked: FALSE
[17:29:42.580]    - call: plan(strategy)
[17:29:42.580] plan(): nbrOfWorkers() = 1
[17:29:42.580] SequentialFuture started (and completed)
[17:29:42.581] - Launch lazy future ... done
[17:29:42.581] run() for 'SequentialFuture' ... done
[17:29:42.582] getGlobalsAndPackages() ...
[17:29:42.582] Searching for globals...
[17:29:42.583] - globals found: [3] '{', 'sample', 'x'
[17:29:42.583] Searching for globals ... DONE
[17:29:42.583] Resolving globals: FALSE
[17:29:42.584] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.585] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.585] - globals: [1] 'x'
[17:29:42.585] 
[17:29:42.585] getGlobalsAndPackages() ... DONE
[17:29:42.585] run() for 'Future' ...
[17:29:42.586] - state: 'created'
[17:29:42.586] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.586] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.586] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.587]   - Field: 'label'
[17:29:42.587]   - Field: 'local'
[17:29:42.587]   - Field: 'owner'
[17:29:42.587]   - Field: 'envir'
[17:29:42.587]   - Field: 'packages'
[17:29:42.590]   - Field: 'gc'
[17:29:42.590]   - Field: 'conditions'
[17:29:42.590]   - Field: 'expr'
[17:29:42.590]   - Field: 'uuid'
[17:29:42.590]   - Field: 'seed'
[17:29:42.591]   - Field: 'version'
[17:29:42.591]   - Field: 'result'
[17:29:42.591]   - Field: 'asynchronous'
[17:29:42.591]   - Field: 'calls'
[17:29:42.591]   - Field: 'globals'
[17:29:42.592]   - Field: 'stdout'
[17:29:42.592]   - Field: 'earlySignal'
[17:29:42.592]   - Field: 'lazy'
[17:29:42.592]   - Field: 'state'
[17:29:42.592] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.593] - Launch lazy future ...
[17:29:42.593] Packages needed by the future expression (n = 0): <none>
[17:29:42.593] Packages needed by future strategies (n = 0): <none>
[17:29:42.594] {
[17:29:42.594]     {
[17:29:42.594]         {
[17:29:42.594]             ...future.startTime <- base::Sys.time()
[17:29:42.594]             {
[17:29:42.594]                 {
[17:29:42.594]                   {
[17:29:42.594]                     base::local({
[17:29:42.594]                       has_future <- base::requireNamespace("future", 
[17:29:42.594]                         quietly = TRUE)
[17:29:42.594]                       if (has_future) {
[17:29:42.594]                         ns <- base::getNamespace("future")
[17:29:42.594]                         version <- ns[[".package"]][["version"]]
[17:29:42.594]                         if (is.null(version)) 
[17:29:42.594]                           version <- utils::packageVersion("future")
[17:29:42.594]                       }
[17:29:42.594]                       else {
[17:29:42.594]                         version <- NULL
[17:29:42.594]                       }
[17:29:42.594]                       if (!has_future || version < "1.8.0") {
[17:29:42.594]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.594]                           "", base::R.version$version.string), 
[17:29:42.594]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.594]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.594]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.594]                             "release", "version")], collapse = " "), 
[17:29:42.594]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.594]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.594]                           info)
[17:29:42.594]                         info <- base::paste(info, collapse = "; ")
[17:29:42.594]                         if (!has_future) {
[17:29:42.594]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.594]                             info)
[17:29:42.594]                         }
[17:29:42.594]                         else {
[17:29:42.594]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.594]                             info, version)
[17:29:42.594]                         }
[17:29:42.594]                         base::stop(msg)
[17:29:42.594]                       }
[17:29:42.594]                     })
[17:29:42.594]                   }
[17:29:42.594]                   ...future.strategy.old <- future::plan("list")
[17:29:42.594]                   options(future.plan = NULL)
[17:29:42.594]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.594]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.594]                 }
[17:29:42.594]                 ...future.workdir <- getwd()
[17:29:42.594]             }
[17:29:42.594]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.594]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.594]         }
[17:29:42.594]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.594]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.594]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.594]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.594]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.594]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.594]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.594]             base::names(...future.oldOptions))
[17:29:42.594]     }
[17:29:42.594]     if (FALSE) {
[17:29:42.594]     }
[17:29:42.594]     else {
[17:29:42.594]         if (TRUE) {
[17:29:42.594]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.594]                 open = "w")
[17:29:42.594]         }
[17:29:42.594]         else {
[17:29:42.594]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.594]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.594]         }
[17:29:42.594]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.594]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.594]             base::sink(type = "output", split = FALSE)
[17:29:42.594]             base::close(...future.stdout)
[17:29:42.594]         }, add = TRUE)
[17:29:42.594]     }
[17:29:42.594]     ...future.frame <- base::sys.nframe()
[17:29:42.594]     ...future.conditions <- base::list()
[17:29:42.594]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.594]     if (FALSE) {
[17:29:42.594]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.594]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.594]     }
[17:29:42.594]     ...future.result <- base::tryCatch({
[17:29:42.594]         base::withCallingHandlers({
[17:29:42.594]             ...future.value <- base::withVisible(base::local({
[17:29:42.594]                 sample(x, size = 1L)
[17:29:42.594]             }))
[17:29:42.594]             future::FutureResult(value = ...future.value$value, 
[17:29:42.594]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.594]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.594]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.594]                     ...future.globalenv.names))
[17:29:42.594]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.594]         }, condition = base::local({
[17:29:42.594]             c <- base::c
[17:29:42.594]             inherits <- base::inherits
[17:29:42.594]             invokeRestart <- base::invokeRestart
[17:29:42.594]             length <- base::length
[17:29:42.594]             list <- base::list
[17:29:42.594]             seq.int <- base::seq.int
[17:29:42.594]             signalCondition <- base::signalCondition
[17:29:42.594]             sys.calls <- base::sys.calls
[17:29:42.594]             `[[` <- base::`[[`
[17:29:42.594]             `+` <- base::`+`
[17:29:42.594]             `<<-` <- base::`<<-`
[17:29:42.594]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.594]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.594]                   3L)]
[17:29:42.594]             }
[17:29:42.594]             function(cond) {
[17:29:42.594]                 is_error <- inherits(cond, "error")
[17:29:42.594]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.594]                   NULL)
[17:29:42.594]                 if (is_error) {
[17:29:42.594]                   sessionInformation <- function() {
[17:29:42.594]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.594]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.594]                       search = base::search(), system = base::Sys.info())
[17:29:42.594]                   }
[17:29:42.594]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.594]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.594]                     cond$call), session = sessionInformation(), 
[17:29:42.594]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.594]                   signalCondition(cond)
[17:29:42.594]                 }
[17:29:42.594]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.594]                 "immediateCondition"))) {
[17:29:42.594]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.594]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.594]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.594]                   if (TRUE && !signal) {
[17:29:42.594]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.594]                     {
[17:29:42.594]                       inherits <- base::inherits
[17:29:42.594]                       invokeRestart <- base::invokeRestart
[17:29:42.594]                       is.null <- base::is.null
[17:29:42.594]                       muffled <- FALSE
[17:29:42.594]                       if (inherits(cond, "message")) {
[17:29:42.594]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.594]                         if (muffled) 
[17:29:42.594]                           invokeRestart("muffleMessage")
[17:29:42.594]                       }
[17:29:42.594]                       else if (inherits(cond, "warning")) {
[17:29:42.594]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.594]                         if (muffled) 
[17:29:42.594]                           invokeRestart("muffleWarning")
[17:29:42.594]                       }
[17:29:42.594]                       else if (inherits(cond, "condition")) {
[17:29:42.594]                         if (!is.null(pattern)) {
[17:29:42.594]                           computeRestarts <- base::computeRestarts
[17:29:42.594]                           grepl <- base::grepl
[17:29:42.594]                           restarts <- computeRestarts(cond)
[17:29:42.594]                           for (restart in restarts) {
[17:29:42.594]                             name <- restart$name
[17:29:42.594]                             if (is.null(name)) 
[17:29:42.594]                               next
[17:29:42.594]                             if (!grepl(pattern, name)) 
[17:29:42.594]                               next
[17:29:42.594]                             invokeRestart(restart)
[17:29:42.594]                             muffled <- TRUE
[17:29:42.594]                             break
[17:29:42.594]                           }
[17:29:42.594]                         }
[17:29:42.594]                       }
[17:29:42.594]                       invisible(muffled)
[17:29:42.594]                     }
[17:29:42.594]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.594]                   }
[17:29:42.594]                 }
[17:29:42.594]                 else {
[17:29:42.594]                   if (TRUE) {
[17:29:42.594]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.594]                     {
[17:29:42.594]                       inherits <- base::inherits
[17:29:42.594]                       invokeRestart <- base::invokeRestart
[17:29:42.594]                       is.null <- base::is.null
[17:29:42.594]                       muffled <- FALSE
[17:29:42.594]                       if (inherits(cond, "message")) {
[17:29:42.594]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.594]                         if (muffled) 
[17:29:42.594]                           invokeRestart("muffleMessage")
[17:29:42.594]                       }
[17:29:42.594]                       else if (inherits(cond, "warning")) {
[17:29:42.594]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.594]                         if (muffled) 
[17:29:42.594]                           invokeRestart("muffleWarning")
[17:29:42.594]                       }
[17:29:42.594]                       else if (inherits(cond, "condition")) {
[17:29:42.594]                         if (!is.null(pattern)) {
[17:29:42.594]                           computeRestarts <- base::computeRestarts
[17:29:42.594]                           grepl <- base::grepl
[17:29:42.594]                           restarts <- computeRestarts(cond)
[17:29:42.594]                           for (restart in restarts) {
[17:29:42.594]                             name <- restart$name
[17:29:42.594]                             if (is.null(name)) 
[17:29:42.594]                               next
[17:29:42.594]                             if (!grepl(pattern, name)) 
[17:29:42.594]                               next
[17:29:42.594]                             invokeRestart(restart)
[17:29:42.594]                             muffled <- TRUE
[17:29:42.594]                             break
[17:29:42.594]                           }
[17:29:42.594]                         }
[17:29:42.594]                       }
[17:29:42.594]                       invisible(muffled)
[17:29:42.594]                     }
[17:29:42.594]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.594]                   }
[17:29:42.594]                 }
[17:29:42.594]             }
[17:29:42.594]         }))
[17:29:42.594]     }, error = function(ex) {
[17:29:42.594]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.594]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.594]                 ...future.rng), started = ...future.startTime, 
[17:29:42.594]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.594]             version = "1.8"), class = "FutureResult")
[17:29:42.594]     }, finally = {
[17:29:42.594]         if (!identical(...future.workdir, getwd())) 
[17:29:42.594]             setwd(...future.workdir)
[17:29:42.594]         {
[17:29:42.594]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.594]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.594]             }
[17:29:42.594]             base::options(...future.oldOptions)
[17:29:42.594]             if (.Platform$OS.type == "windows") {
[17:29:42.594]                 old_names <- names(...future.oldEnvVars)
[17:29:42.594]                 envs <- base::Sys.getenv()
[17:29:42.594]                 names <- names(envs)
[17:29:42.594]                 common <- intersect(names, old_names)
[17:29:42.594]                 added <- setdiff(names, old_names)
[17:29:42.594]                 removed <- setdiff(old_names, names)
[17:29:42.594]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.594]                   envs[common]]
[17:29:42.594]                 NAMES <- toupper(changed)
[17:29:42.594]                 args <- list()
[17:29:42.594]                 for (kk in seq_along(NAMES)) {
[17:29:42.594]                   name <- changed[[kk]]
[17:29:42.594]                   NAME <- NAMES[[kk]]
[17:29:42.594]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.594]                     next
[17:29:42.594]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.594]                 }
[17:29:42.594]                 NAMES <- toupper(added)
[17:29:42.594]                 for (kk in seq_along(NAMES)) {
[17:29:42.594]                   name <- added[[kk]]
[17:29:42.594]                   NAME <- NAMES[[kk]]
[17:29:42.594]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.594]                     next
[17:29:42.594]                   args[[name]] <- ""
[17:29:42.594]                 }
[17:29:42.594]                 NAMES <- toupper(removed)
[17:29:42.594]                 for (kk in seq_along(NAMES)) {
[17:29:42.594]                   name <- removed[[kk]]
[17:29:42.594]                   NAME <- NAMES[[kk]]
[17:29:42.594]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.594]                     next
[17:29:42.594]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.594]                 }
[17:29:42.594]                 if (length(args) > 0) 
[17:29:42.594]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.594]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.594]             }
[17:29:42.594]             else {
[17:29:42.594]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.594]             }
[17:29:42.594]             {
[17:29:42.594]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.594]                   0L) {
[17:29:42.594]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.594]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.594]                   base::options(opts)
[17:29:42.594]                 }
[17:29:42.594]                 {
[17:29:42.594]                   {
[17:29:42.594]                     base::assign(".Random.seed", c(10407L, 1341507001L, 
[17:29:42.594]                     -1961694787L, 5022314L, 1571014043L, -1264788569L, 
[17:29:42.594]                     -798616520L), envir = base::globalenv(), 
[17:29:42.594]                       inherits = FALSE)
[17:29:42.594]                     NULL
[17:29:42.594]                   }
[17:29:42.594]                   options(future.plan = NULL)
[17:29:42.594]                   if (is.na(NA_character_)) 
[17:29:42.594]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.594]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.594]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.594]                     .init = FALSE)
[17:29:42.594]                 }
[17:29:42.594]             }
[17:29:42.594]         }
[17:29:42.594]     })
[17:29:42.594]     if (TRUE) {
[17:29:42.594]         base::sink(type = "output", split = FALSE)
[17:29:42.594]         if (TRUE) {
[17:29:42.594]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.594]         }
[17:29:42.594]         else {
[17:29:42.594]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.594]         }
[17:29:42.594]         base::close(...future.stdout)
[17:29:42.594]         ...future.stdout <- NULL
[17:29:42.594]     }
[17:29:42.594]     ...future.result$conditions <- ...future.conditions
[17:29:42.594]     ...future.result$finished <- base::Sys.time()
[17:29:42.594]     ...future.result
[17:29:42.594] }
[17:29:42.598] assign_globals() ...
[17:29:42.598] List of 1
[17:29:42.598]  $ x: int [1:4] 0 1 2 3
[17:29:42.598]  - attr(*, "where")=List of 1
[17:29:42.598]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.598]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.598]  - attr(*, "resolved")= logi FALSE
[17:29:42.598]  - attr(*, "total_size")= int 133
[17:29:42.598]  - attr(*, "already-done")= logi TRUE
[17:29:42.604] - copied 'x' to environment
[17:29:42.604] assign_globals() ... done
[17:29:42.605] plan(): Setting new future strategy stack:
[17:29:42.605] List of future strategies:
[17:29:42.605] 1. sequential:
[17:29:42.605]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.605]    - tweaked: FALSE
[17:29:42.605]    - call: NULL
[17:29:42.606] plan(): nbrOfWorkers() = 1
[17:29:42.607] plan(): Setting new future strategy stack:
[17:29:42.607] List of future strategies:
[17:29:42.607] 1. sequential:
[17:29:42.607]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.607]    - tweaked: FALSE
[17:29:42.607]    - call: plan(strategy)
[17:29:42.608] plan(): nbrOfWorkers() = 1
[17:29:42.609] SequentialFuture started (and completed)
[17:29:42.609] - Launch lazy future ... done
[17:29:42.609] run() for 'SequentialFuture' ... done
[17:29:42.610] getGlobalsAndPackages() ...
[17:29:42.610] Searching for globals...
[17:29:42.611] - globals found: [3] '{', 'sample', 'x'
[17:29:42.612] Searching for globals ... DONE
[17:29:42.612] Resolving globals: FALSE
[17:29:42.612] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.613] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.613] - globals: [1] 'x'
[17:29:42.613] 
[17:29:42.613] getGlobalsAndPackages() ... DONE
[17:29:42.614] run() for 'Future' ...
[17:29:42.614] - state: 'created'
[17:29:42.614] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.615] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.615] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.615]   - Field: 'label'
[17:29:42.615]   - Field: 'local'
[17:29:42.615]   - Field: 'owner'
[17:29:42.616]   - Field: 'envir'
[17:29:42.616]   - Field: 'packages'
[17:29:42.616]   - Field: 'gc'
[17:29:42.616]   - Field: 'conditions'
[17:29:42.616]   - Field: 'expr'
[17:29:42.617]   - Field: 'uuid'
[17:29:42.617]   - Field: 'seed'
[17:29:42.617]   - Field: 'version'
[17:29:42.617]   - Field: 'result'
[17:29:42.617]   - Field: 'asynchronous'
[17:29:42.618]   - Field: 'calls'
[17:29:42.618]   - Field: 'globals'
[17:29:42.618]   - Field: 'stdout'
[17:29:42.618]   - Field: 'earlySignal'
[17:29:42.618]   - Field: 'lazy'
[17:29:42.618]   - Field: 'state'
[17:29:42.619] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.619] - Launch lazy future ...
[17:29:42.619] Packages needed by the future expression (n = 0): <none>
[17:29:42.619] Packages needed by future strategies (n = 0): <none>
[17:29:42.620] {
[17:29:42.620]     {
[17:29:42.620]         {
[17:29:42.620]             ...future.startTime <- base::Sys.time()
[17:29:42.620]             {
[17:29:42.620]                 {
[17:29:42.620]                   {
[17:29:42.620]                     base::local({
[17:29:42.620]                       has_future <- base::requireNamespace("future", 
[17:29:42.620]                         quietly = TRUE)
[17:29:42.620]                       if (has_future) {
[17:29:42.620]                         ns <- base::getNamespace("future")
[17:29:42.620]                         version <- ns[[".package"]][["version"]]
[17:29:42.620]                         if (is.null(version)) 
[17:29:42.620]                           version <- utils::packageVersion("future")
[17:29:42.620]                       }
[17:29:42.620]                       else {
[17:29:42.620]                         version <- NULL
[17:29:42.620]                       }
[17:29:42.620]                       if (!has_future || version < "1.8.0") {
[17:29:42.620]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.620]                           "", base::R.version$version.string), 
[17:29:42.620]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.620]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.620]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.620]                             "release", "version")], collapse = " "), 
[17:29:42.620]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.620]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.620]                           info)
[17:29:42.620]                         info <- base::paste(info, collapse = "; ")
[17:29:42.620]                         if (!has_future) {
[17:29:42.620]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.620]                             info)
[17:29:42.620]                         }
[17:29:42.620]                         else {
[17:29:42.620]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.620]                             info, version)
[17:29:42.620]                         }
[17:29:42.620]                         base::stop(msg)
[17:29:42.620]                       }
[17:29:42.620]                     })
[17:29:42.620]                   }
[17:29:42.620]                   ...future.strategy.old <- future::plan("list")
[17:29:42.620]                   options(future.plan = NULL)
[17:29:42.620]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.620]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.620]                 }
[17:29:42.620]                 ...future.workdir <- getwd()
[17:29:42.620]             }
[17:29:42.620]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.620]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.620]         }
[17:29:42.620]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.620]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.620]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.620]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.620]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.620]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.620]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.620]             base::names(...future.oldOptions))
[17:29:42.620]     }
[17:29:42.620]     if (FALSE) {
[17:29:42.620]     }
[17:29:42.620]     else {
[17:29:42.620]         if (TRUE) {
[17:29:42.620]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.620]                 open = "w")
[17:29:42.620]         }
[17:29:42.620]         else {
[17:29:42.620]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.620]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.620]         }
[17:29:42.620]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.620]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.620]             base::sink(type = "output", split = FALSE)
[17:29:42.620]             base::close(...future.stdout)
[17:29:42.620]         }, add = TRUE)
[17:29:42.620]     }
[17:29:42.620]     ...future.frame <- base::sys.nframe()
[17:29:42.620]     ...future.conditions <- base::list()
[17:29:42.620]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.620]     if (FALSE) {
[17:29:42.620]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.620]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.620]     }
[17:29:42.620]     ...future.result <- base::tryCatch({
[17:29:42.620]         base::withCallingHandlers({
[17:29:42.620]             ...future.value <- base::withVisible(base::local({
[17:29:42.620]                 sample(x, size = 1L)
[17:29:42.620]             }))
[17:29:42.620]             future::FutureResult(value = ...future.value$value, 
[17:29:42.620]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.620]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.620]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.620]                     ...future.globalenv.names))
[17:29:42.620]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.620]         }, condition = base::local({
[17:29:42.620]             c <- base::c
[17:29:42.620]             inherits <- base::inherits
[17:29:42.620]             invokeRestart <- base::invokeRestart
[17:29:42.620]             length <- base::length
[17:29:42.620]             list <- base::list
[17:29:42.620]             seq.int <- base::seq.int
[17:29:42.620]             signalCondition <- base::signalCondition
[17:29:42.620]             sys.calls <- base::sys.calls
[17:29:42.620]             `[[` <- base::`[[`
[17:29:42.620]             `+` <- base::`+`
[17:29:42.620]             `<<-` <- base::`<<-`
[17:29:42.620]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.620]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.620]                   3L)]
[17:29:42.620]             }
[17:29:42.620]             function(cond) {
[17:29:42.620]                 is_error <- inherits(cond, "error")
[17:29:42.620]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.620]                   NULL)
[17:29:42.620]                 if (is_error) {
[17:29:42.620]                   sessionInformation <- function() {
[17:29:42.620]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.620]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.620]                       search = base::search(), system = base::Sys.info())
[17:29:42.620]                   }
[17:29:42.620]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.620]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.620]                     cond$call), session = sessionInformation(), 
[17:29:42.620]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.620]                   signalCondition(cond)
[17:29:42.620]                 }
[17:29:42.620]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.620]                 "immediateCondition"))) {
[17:29:42.620]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.620]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.620]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.620]                   if (TRUE && !signal) {
[17:29:42.620]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.620]                     {
[17:29:42.620]                       inherits <- base::inherits
[17:29:42.620]                       invokeRestart <- base::invokeRestart
[17:29:42.620]                       is.null <- base::is.null
[17:29:42.620]                       muffled <- FALSE
[17:29:42.620]                       if (inherits(cond, "message")) {
[17:29:42.620]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.620]                         if (muffled) 
[17:29:42.620]                           invokeRestart("muffleMessage")
[17:29:42.620]                       }
[17:29:42.620]                       else if (inherits(cond, "warning")) {
[17:29:42.620]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.620]                         if (muffled) 
[17:29:42.620]                           invokeRestart("muffleWarning")
[17:29:42.620]                       }
[17:29:42.620]                       else if (inherits(cond, "condition")) {
[17:29:42.620]                         if (!is.null(pattern)) {
[17:29:42.620]                           computeRestarts <- base::computeRestarts
[17:29:42.620]                           grepl <- base::grepl
[17:29:42.620]                           restarts <- computeRestarts(cond)
[17:29:42.620]                           for (restart in restarts) {
[17:29:42.620]                             name <- restart$name
[17:29:42.620]                             if (is.null(name)) 
[17:29:42.620]                               next
[17:29:42.620]                             if (!grepl(pattern, name)) 
[17:29:42.620]                               next
[17:29:42.620]                             invokeRestart(restart)
[17:29:42.620]                             muffled <- TRUE
[17:29:42.620]                             break
[17:29:42.620]                           }
[17:29:42.620]                         }
[17:29:42.620]                       }
[17:29:42.620]                       invisible(muffled)
[17:29:42.620]                     }
[17:29:42.620]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.620]                   }
[17:29:42.620]                 }
[17:29:42.620]                 else {
[17:29:42.620]                   if (TRUE) {
[17:29:42.620]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.620]                     {
[17:29:42.620]                       inherits <- base::inherits
[17:29:42.620]                       invokeRestart <- base::invokeRestart
[17:29:42.620]                       is.null <- base::is.null
[17:29:42.620]                       muffled <- FALSE
[17:29:42.620]                       if (inherits(cond, "message")) {
[17:29:42.620]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.620]                         if (muffled) 
[17:29:42.620]                           invokeRestart("muffleMessage")
[17:29:42.620]                       }
[17:29:42.620]                       else if (inherits(cond, "warning")) {
[17:29:42.620]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.620]                         if (muffled) 
[17:29:42.620]                           invokeRestart("muffleWarning")
[17:29:42.620]                       }
[17:29:42.620]                       else if (inherits(cond, "condition")) {
[17:29:42.620]                         if (!is.null(pattern)) {
[17:29:42.620]                           computeRestarts <- base::computeRestarts
[17:29:42.620]                           grepl <- base::grepl
[17:29:42.620]                           restarts <- computeRestarts(cond)
[17:29:42.620]                           for (restart in restarts) {
[17:29:42.620]                             name <- restart$name
[17:29:42.620]                             if (is.null(name)) 
[17:29:42.620]                               next
[17:29:42.620]                             if (!grepl(pattern, name)) 
[17:29:42.620]                               next
[17:29:42.620]                             invokeRestart(restart)
[17:29:42.620]                             muffled <- TRUE
[17:29:42.620]                             break
[17:29:42.620]                           }
[17:29:42.620]                         }
[17:29:42.620]                       }
[17:29:42.620]                       invisible(muffled)
[17:29:42.620]                     }
[17:29:42.620]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.620]                   }
[17:29:42.620]                 }
[17:29:42.620]             }
[17:29:42.620]         }))
[17:29:42.620]     }, error = function(ex) {
[17:29:42.620]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.620]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.620]                 ...future.rng), started = ...future.startTime, 
[17:29:42.620]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.620]             version = "1.8"), class = "FutureResult")
[17:29:42.620]     }, finally = {
[17:29:42.620]         if (!identical(...future.workdir, getwd())) 
[17:29:42.620]             setwd(...future.workdir)
[17:29:42.620]         {
[17:29:42.620]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.620]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.620]             }
[17:29:42.620]             base::options(...future.oldOptions)
[17:29:42.620]             if (.Platform$OS.type == "windows") {
[17:29:42.620]                 old_names <- names(...future.oldEnvVars)
[17:29:42.620]                 envs <- base::Sys.getenv()
[17:29:42.620]                 names <- names(envs)
[17:29:42.620]                 common <- intersect(names, old_names)
[17:29:42.620]                 added <- setdiff(names, old_names)
[17:29:42.620]                 removed <- setdiff(old_names, names)
[17:29:42.620]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.620]                   envs[common]]
[17:29:42.620]                 NAMES <- toupper(changed)
[17:29:42.620]                 args <- list()
[17:29:42.620]                 for (kk in seq_along(NAMES)) {
[17:29:42.620]                   name <- changed[[kk]]
[17:29:42.620]                   NAME <- NAMES[[kk]]
[17:29:42.620]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.620]                     next
[17:29:42.620]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.620]                 }
[17:29:42.620]                 NAMES <- toupper(added)
[17:29:42.620]                 for (kk in seq_along(NAMES)) {
[17:29:42.620]                   name <- added[[kk]]
[17:29:42.620]                   NAME <- NAMES[[kk]]
[17:29:42.620]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.620]                     next
[17:29:42.620]                   args[[name]] <- ""
[17:29:42.620]                 }
[17:29:42.620]                 NAMES <- toupper(removed)
[17:29:42.620]                 for (kk in seq_along(NAMES)) {
[17:29:42.620]                   name <- removed[[kk]]
[17:29:42.620]                   NAME <- NAMES[[kk]]
[17:29:42.620]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.620]                     next
[17:29:42.620]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.620]                 }
[17:29:42.620]                 if (length(args) > 0) 
[17:29:42.620]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.620]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.620]             }
[17:29:42.620]             else {
[17:29:42.620]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.620]             }
[17:29:42.620]             {
[17:29:42.620]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.620]                   0L) {
[17:29:42.620]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.620]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.620]                   base::options(opts)
[17:29:42.620]                 }
[17:29:42.620]                 {
[17:29:42.620]                   {
[17:29:42.620]                     base::assign(".Random.seed", c(10407L, 5022314L, 
[17:29:42.620]                     797175219L, 1357813559L, -798616520L, -671125464L, 
[17:29:42.620]                     2060151254L), envir = base::globalenv(), 
[17:29:42.620]                       inherits = FALSE)
[17:29:42.620]                     NULL
[17:29:42.620]                   }
[17:29:42.620]                   options(future.plan = NULL)
[17:29:42.620]                   if (is.na(NA_character_)) 
[17:29:42.620]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.620]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.620]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.620]                     .init = FALSE)
[17:29:42.620]                 }
[17:29:42.620]             }
[17:29:42.620]         }
[17:29:42.620]     })
[17:29:42.620]     if (TRUE) {
[17:29:42.620]         base::sink(type = "output", split = FALSE)
[17:29:42.620]         if (TRUE) {
[17:29:42.620]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.620]         }
[17:29:42.620]         else {
[17:29:42.620]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.620]         }
[17:29:42.620]         base::close(...future.stdout)
[17:29:42.620]         ...future.stdout <- NULL
[17:29:42.620]     }
[17:29:42.620]     ...future.result$conditions <- ...future.conditions
[17:29:42.620]     ...future.result$finished <- base::Sys.time()
[17:29:42.620]     ...future.result
[17:29:42.620] }
[17:29:42.624] assign_globals() ...
[17:29:42.624] List of 1
[17:29:42.624]  $ x: int [1:4] 0 1 2 3
[17:29:42.624]  - attr(*, "where")=List of 1
[17:29:42.624]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.624]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.624]  - attr(*, "resolved")= logi FALSE
[17:29:42.624]  - attr(*, "total_size")= int 133
[17:29:42.624]  - attr(*, "already-done")= logi TRUE
[17:29:42.630] - copied 'x' to environment
[17:29:42.630] assign_globals() ... done
[17:29:42.630] plan(): Setting new future strategy stack:
[17:29:42.630] List of future strategies:
[17:29:42.630] 1. sequential:
[17:29:42.630]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.630]    - tweaked: FALSE
[17:29:42.630]    - call: NULL
[17:29:42.631] plan(): nbrOfWorkers() = 1
[17:29:42.633] plan(): Setting new future strategy stack:
[17:29:42.633] List of future strategies:
[17:29:42.633] 1. sequential:
[17:29:42.633]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.633]    - tweaked: FALSE
[17:29:42.633]    - call: plan(strategy)
[17:29:42.634] plan(): nbrOfWorkers() = 1
[17:29:42.634] SequentialFuture started (and completed)
[17:29:42.634] - Launch lazy future ... done
[17:29:42.634] run() for 'SequentialFuture' ... done
[[1]]
[1] 2

[[2]]
[1] 2

[[3]]
[1] 0

[[4]]
[1] 3

[17:29:42.636] getGlobalsAndPackages() ...
[17:29:42.636] Searching for globals...
[17:29:42.637] - globals found: [3] '{', 'sample', 'x'
[17:29:42.637] Searching for globals ... DONE
[17:29:42.638] Resolving globals: FALSE
[17:29:42.638] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.639] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.639] - globals: [1] 'x'
[17:29:42.639] 
[17:29:42.639] getGlobalsAndPackages() ... DONE
[17:29:42.639] run() for 'Future' ...
[17:29:42.640] - state: 'created'
[17:29:42.640] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.640] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.640] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.641]   - Field: 'label'
[17:29:42.641]   - Field: 'local'
[17:29:42.641]   - Field: 'owner'
[17:29:42.641]   - Field: 'envir'
[17:29:42.641]   - Field: 'packages'
[17:29:42.642]   - Field: 'gc'
[17:29:42.642]   - Field: 'conditions'
[17:29:42.642]   - Field: 'expr'
[17:29:42.642]   - Field: 'uuid'
[17:29:42.642]   - Field: 'seed'
[17:29:42.642]   - Field: 'version'
[17:29:42.643]   - Field: 'result'
[17:29:42.643]   - Field: 'asynchronous'
[17:29:42.643]   - Field: 'calls'
[17:29:42.643]   - Field: 'globals'
[17:29:42.643]   - Field: 'stdout'
[17:29:42.643]   - Field: 'earlySignal'
[17:29:42.644]   - Field: 'lazy'
[17:29:42.644]   - Field: 'state'
[17:29:42.645] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.645] - Launch lazy future ...
[17:29:42.646] Packages needed by the future expression (n = 0): <none>
[17:29:42.646] Packages needed by future strategies (n = 0): <none>
[17:29:42.647] {
[17:29:42.647]     {
[17:29:42.647]         {
[17:29:42.647]             ...future.startTime <- base::Sys.time()
[17:29:42.647]             {
[17:29:42.647]                 {
[17:29:42.647]                   {
[17:29:42.647]                     base::local({
[17:29:42.647]                       has_future <- base::requireNamespace("future", 
[17:29:42.647]                         quietly = TRUE)
[17:29:42.647]                       if (has_future) {
[17:29:42.647]                         ns <- base::getNamespace("future")
[17:29:42.647]                         version <- ns[[".package"]][["version"]]
[17:29:42.647]                         if (is.null(version)) 
[17:29:42.647]                           version <- utils::packageVersion("future")
[17:29:42.647]                       }
[17:29:42.647]                       else {
[17:29:42.647]                         version <- NULL
[17:29:42.647]                       }
[17:29:42.647]                       if (!has_future || version < "1.8.0") {
[17:29:42.647]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.647]                           "", base::R.version$version.string), 
[17:29:42.647]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.647]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.647]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.647]                             "release", "version")], collapse = " "), 
[17:29:42.647]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.647]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.647]                           info)
[17:29:42.647]                         info <- base::paste(info, collapse = "; ")
[17:29:42.647]                         if (!has_future) {
[17:29:42.647]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.647]                             info)
[17:29:42.647]                         }
[17:29:42.647]                         else {
[17:29:42.647]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.647]                             info, version)
[17:29:42.647]                         }
[17:29:42.647]                         base::stop(msg)
[17:29:42.647]                       }
[17:29:42.647]                     })
[17:29:42.647]                   }
[17:29:42.647]                   ...future.strategy.old <- future::plan("list")
[17:29:42.647]                   options(future.plan = NULL)
[17:29:42.647]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.647]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.647]                 }
[17:29:42.647]                 ...future.workdir <- getwd()
[17:29:42.647]             }
[17:29:42.647]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.647]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.647]         }
[17:29:42.647]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.647]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.647]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.647]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.647]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.647]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.647]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.647]             base::names(...future.oldOptions))
[17:29:42.647]     }
[17:29:42.647]     if (FALSE) {
[17:29:42.647]     }
[17:29:42.647]     else {
[17:29:42.647]         if (TRUE) {
[17:29:42.647]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.647]                 open = "w")
[17:29:42.647]         }
[17:29:42.647]         else {
[17:29:42.647]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.647]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.647]         }
[17:29:42.647]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.647]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.647]             base::sink(type = "output", split = FALSE)
[17:29:42.647]             base::close(...future.stdout)
[17:29:42.647]         }, add = TRUE)
[17:29:42.647]     }
[17:29:42.647]     ...future.frame <- base::sys.nframe()
[17:29:42.647]     ...future.conditions <- base::list()
[17:29:42.647]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.647]     if (FALSE) {
[17:29:42.647]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.647]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.647]     }
[17:29:42.647]     ...future.result <- base::tryCatch({
[17:29:42.647]         base::withCallingHandlers({
[17:29:42.647]             ...future.value <- base::withVisible(base::local({
[17:29:42.647]                 sample(x, size = 1L)
[17:29:42.647]             }))
[17:29:42.647]             future::FutureResult(value = ...future.value$value, 
[17:29:42.647]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.647]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.647]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.647]                     ...future.globalenv.names))
[17:29:42.647]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.647]         }, condition = base::local({
[17:29:42.647]             c <- base::c
[17:29:42.647]             inherits <- base::inherits
[17:29:42.647]             invokeRestart <- base::invokeRestart
[17:29:42.647]             length <- base::length
[17:29:42.647]             list <- base::list
[17:29:42.647]             seq.int <- base::seq.int
[17:29:42.647]             signalCondition <- base::signalCondition
[17:29:42.647]             sys.calls <- base::sys.calls
[17:29:42.647]             `[[` <- base::`[[`
[17:29:42.647]             `+` <- base::`+`
[17:29:42.647]             `<<-` <- base::`<<-`
[17:29:42.647]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.647]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.647]                   3L)]
[17:29:42.647]             }
[17:29:42.647]             function(cond) {
[17:29:42.647]                 is_error <- inherits(cond, "error")
[17:29:42.647]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.647]                   NULL)
[17:29:42.647]                 if (is_error) {
[17:29:42.647]                   sessionInformation <- function() {
[17:29:42.647]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.647]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.647]                       search = base::search(), system = base::Sys.info())
[17:29:42.647]                   }
[17:29:42.647]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.647]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.647]                     cond$call), session = sessionInformation(), 
[17:29:42.647]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.647]                   signalCondition(cond)
[17:29:42.647]                 }
[17:29:42.647]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.647]                 "immediateCondition"))) {
[17:29:42.647]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.647]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.647]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.647]                   if (TRUE && !signal) {
[17:29:42.647]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.647]                     {
[17:29:42.647]                       inherits <- base::inherits
[17:29:42.647]                       invokeRestart <- base::invokeRestart
[17:29:42.647]                       is.null <- base::is.null
[17:29:42.647]                       muffled <- FALSE
[17:29:42.647]                       if (inherits(cond, "message")) {
[17:29:42.647]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.647]                         if (muffled) 
[17:29:42.647]                           invokeRestart("muffleMessage")
[17:29:42.647]                       }
[17:29:42.647]                       else if (inherits(cond, "warning")) {
[17:29:42.647]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.647]                         if (muffled) 
[17:29:42.647]                           invokeRestart("muffleWarning")
[17:29:42.647]                       }
[17:29:42.647]                       else if (inherits(cond, "condition")) {
[17:29:42.647]                         if (!is.null(pattern)) {
[17:29:42.647]                           computeRestarts <- base::computeRestarts
[17:29:42.647]                           grepl <- base::grepl
[17:29:42.647]                           restarts <- computeRestarts(cond)
[17:29:42.647]                           for (restart in restarts) {
[17:29:42.647]                             name <- restart$name
[17:29:42.647]                             if (is.null(name)) 
[17:29:42.647]                               next
[17:29:42.647]                             if (!grepl(pattern, name)) 
[17:29:42.647]                               next
[17:29:42.647]                             invokeRestart(restart)
[17:29:42.647]                             muffled <- TRUE
[17:29:42.647]                             break
[17:29:42.647]                           }
[17:29:42.647]                         }
[17:29:42.647]                       }
[17:29:42.647]                       invisible(muffled)
[17:29:42.647]                     }
[17:29:42.647]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.647]                   }
[17:29:42.647]                 }
[17:29:42.647]                 else {
[17:29:42.647]                   if (TRUE) {
[17:29:42.647]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.647]                     {
[17:29:42.647]                       inherits <- base::inherits
[17:29:42.647]                       invokeRestart <- base::invokeRestart
[17:29:42.647]                       is.null <- base::is.null
[17:29:42.647]                       muffled <- FALSE
[17:29:42.647]                       if (inherits(cond, "message")) {
[17:29:42.647]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.647]                         if (muffled) 
[17:29:42.647]                           invokeRestart("muffleMessage")
[17:29:42.647]                       }
[17:29:42.647]                       else if (inherits(cond, "warning")) {
[17:29:42.647]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.647]                         if (muffled) 
[17:29:42.647]                           invokeRestart("muffleWarning")
[17:29:42.647]                       }
[17:29:42.647]                       else if (inherits(cond, "condition")) {
[17:29:42.647]                         if (!is.null(pattern)) {
[17:29:42.647]                           computeRestarts <- base::computeRestarts
[17:29:42.647]                           grepl <- base::grepl
[17:29:42.647]                           restarts <- computeRestarts(cond)
[17:29:42.647]                           for (restart in restarts) {
[17:29:42.647]                             name <- restart$name
[17:29:42.647]                             if (is.null(name)) 
[17:29:42.647]                               next
[17:29:42.647]                             if (!grepl(pattern, name)) 
[17:29:42.647]                               next
[17:29:42.647]                             invokeRestart(restart)
[17:29:42.647]                             muffled <- TRUE
[17:29:42.647]                             break
[17:29:42.647]                           }
[17:29:42.647]                         }
[17:29:42.647]                       }
[17:29:42.647]                       invisible(muffled)
[17:29:42.647]                     }
[17:29:42.647]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.647]                   }
[17:29:42.647]                 }
[17:29:42.647]             }
[17:29:42.647]         }))
[17:29:42.647]     }, error = function(ex) {
[17:29:42.647]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.647]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.647]                 ...future.rng), started = ...future.startTime, 
[17:29:42.647]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.647]             version = "1.8"), class = "FutureResult")
[17:29:42.647]     }, finally = {
[17:29:42.647]         if (!identical(...future.workdir, getwd())) 
[17:29:42.647]             setwd(...future.workdir)
[17:29:42.647]         {
[17:29:42.647]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.647]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.647]             }
[17:29:42.647]             base::options(...future.oldOptions)
[17:29:42.647]             if (.Platform$OS.type == "windows") {
[17:29:42.647]                 old_names <- names(...future.oldEnvVars)
[17:29:42.647]                 envs <- base::Sys.getenv()
[17:29:42.647]                 names <- names(envs)
[17:29:42.647]                 common <- intersect(names, old_names)
[17:29:42.647]                 added <- setdiff(names, old_names)
[17:29:42.647]                 removed <- setdiff(old_names, names)
[17:29:42.647]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.647]                   envs[common]]
[17:29:42.647]                 NAMES <- toupper(changed)
[17:29:42.647]                 args <- list()
[17:29:42.647]                 for (kk in seq_along(NAMES)) {
[17:29:42.647]                   name <- changed[[kk]]
[17:29:42.647]                   NAME <- NAMES[[kk]]
[17:29:42.647]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.647]                     next
[17:29:42.647]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.647]                 }
[17:29:42.647]                 NAMES <- toupper(added)
[17:29:42.647]                 for (kk in seq_along(NAMES)) {
[17:29:42.647]                   name <- added[[kk]]
[17:29:42.647]                   NAME <- NAMES[[kk]]
[17:29:42.647]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.647]                     next
[17:29:42.647]                   args[[name]] <- ""
[17:29:42.647]                 }
[17:29:42.647]                 NAMES <- toupper(removed)
[17:29:42.647]                 for (kk in seq_along(NAMES)) {
[17:29:42.647]                   name <- removed[[kk]]
[17:29:42.647]                   NAME <- NAMES[[kk]]
[17:29:42.647]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.647]                     next
[17:29:42.647]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.647]                 }
[17:29:42.647]                 if (length(args) > 0) 
[17:29:42.647]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.647]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.647]             }
[17:29:42.647]             else {
[17:29:42.647]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.647]             }
[17:29:42.647]             {
[17:29:42.647]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.647]                   0L) {
[17:29:42.647]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.647]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.647]                   base::options(opts)
[17:29:42.647]                 }
[17:29:42.647]                 {
[17:29:42.647]                   {
[17:29:42.647]                     base::assign(".Random.seed", c(10407L, 1109576272L, 
[17:29:42.647]                     -1196620031L, 856904683L, -596522873L, -1403402474L, 
[17:29:42.647]                     -594096583L), envir = base::globalenv(), 
[17:29:42.647]                       inherits = FALSE)
[17:29:42.647]                     NULL
[17:29:42.647]                   }
[17:29:42.647]                   options(future.plan = NULL)
[17:29:42.647]                   if (is.na(NA_character_)) 
[17:29:42.647]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.647]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.647]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.647]                     .init = FALSE)
[17:29:42.647]                 }
[17:29:42.647]             }
[17:29:42.647]         }
[17:29:42.647]     })
[17:29:42.647]     if (TRUE) {
[17:29:42.647]         base::sink(type = "output", split = FALSE)
[17:29:42.647]         if (TRUE) {
[17:29:42.647]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.647]         }
[17:29:42.647]         else {
[17:29:42.647]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.647]         }
[17:29:42.647]         base::close(...future.stdout)
[17:29:42.647]         ...future.stdout <- NULL
[17:29:42.647]     }
[17:29:42.647]     ...future.result$conditions <- ...future.conditions
[17:29:42.647]     ...future.result$finished <- base::Sys.time()
[17:29:42.647]     ...future.result
[17:29:42.647] }
[17:29:42.654] assign_globals() ...
[17:29:42.654] List of 1
[17:29:42.654]  $ x: int [1:4] 0 1 2 3
[17:29:42.654]  - attr(*, "where")=List of 1
[17:29:42.654]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.654]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.654]  - attr(*, "resolved")= logi FALSE
[17:29:42.654]  - attr(*, "total_size")= int 133
[17:29:42.654]  - attr(*, "already-done")= logi TRUE
[17:29:42.660] - copied 'x' to environment
[17:29:42.660] assign_globals() ... done
[17:29:42.661] plan(): Setting new future strategy stack:
[17:29:42.661] List of future strategies:
[17:29:42.661] 1. sequential:
[17:29:42.661]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.661]    - tweaked: FALSE
[17:29:42.661]    - call: NULL
[17:29:42.662] plan(): nbrOfWorkers() = 1
[17:29:42.664] plan(): Setting new future strategy stack:
[17:29:42.665] List of future strategies:
[17:29:42.665] 1. sequential:
[17:29:42.665]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.665]    - tweaked: FALSE
[17:29:42.665]    - call: plan(strategy)
[17:29:42.666] plan(): nbrOfWorkers() = 1
[17:29:42.666] SequentialFuture started (and completed)
[17:29:42.666] - Launch lazy future ... done
[17:29:42.667] run() for 'SequentialFuture' ... done
[17:29:42.668] getGlobalsAndPackages() ...
[17:29:42.668] Searching for globals...
[17:29:42.674] - globals found: [3] '{', 'sample', 'x'
[17:29:42.674] Searching for globals ... DONE
[17:29:42.674] Resolving globals: FALSE
[17:29:42.675] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.676] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.676] - globals: [1] 'x'
[17:29:42.677] 
[17:29:42.677] getGlobalsAndPackages() ... DONE
[17:29:42.678] run() for 'Future' ...
[17:29:42.678] - state: 'created'
[17:29:42.678] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.679] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.679] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.680]   - Field: 'label'
[17:29:42.680]   - Field: 'local'
[17:29:42.680]   - Field: 'owner'
[17:29:42.681]   - Field: 'envir'
[17:29:42.681]   - Field: 'packages'
[17:29:42.681]   - Field: 'gc'
[17:29:42.682]   - Field: 'conditions'
[17:29:42.682]   - Field: 'expr'
[17:29:42.682]   - Field: 'uuid'
[17:29:42.683]   - Field: 'seed'
[17:29:42.683]   - Field: 'version'
[17:29:42.683]   - Field: 'result'
[17:29:42.684]   - Field: 'asynchronous'
[17:29:42.684]   - Field: 'calls'
[17:29:42.684]   - Field: 'globals'
[17:29:42.685]   - Field: 'stdout'
[17:29:42.685]   - Field: 'earlySignal'
[17:29:42.685]   - Field: 'lazy'
[17:29:42.685]   - Field: 'state'
[17:29:42.686] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.686] - Launch lazy future ...
[17:29:42.686] Packages needed by the future expression (n = 0): <none>
[17:29:42.687] Packages needed by future strategies (n = 0): <none>
[17:29:42.688] {
[17:29:42.688]     {
[17:29:42.688]         {
[17:29:42.688]             ...future.startTime <- base::Sys.time()
[17:29:42.688]             {
[17:29:42.688]                 {
[17:29:42.688]                   {
[17:29:42.688]                     base::local({
[17:29:42.688]                       has_future <- base::requireNamespace("future", 
[17:29:42.688]                         quietly = TRUE)
[17:29:42.688]                       if (has_future) {
[17:29:42.688]                         ns <- base::getNamespace("future")
[17:29:42.688]                         version <- ns[[".package"]][["version"]]
[17:29:42.688]                         if (is.null(version)) 
[17:29:42.688]                           version <- utils::packageVersion("future")
[17:29:42.688]                       }
[17:29:42.688]                       else {
[17:29:42.688]                         version <- NULL
[17:29:42.688]                       }
[17:29:42.688]                       if (!has_future || version < "1.8.0") {
[17:29:42.688]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.688]                           "", base::R.version$version.string), 
[17:29:42.688]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.688]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.688]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.688]                             "release", "version")], collapse = " "), 
[17:29:42.688]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.688]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.688]                           info)
[17:29:42.688]                         info <- base::paste(info, collapse = "; ")
[17:29:42.688]                         if (!has_future) {
[17:29:42.688]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.688]                             info)
[17:29:42.688]                         }
[17:29:42.688]                         else {
[17:29:42.688]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.688]                             info, version)
[17:29:42.688]                         }
[17:29:42.688]                         base::stop(msg)
[17:29:42.688]                       }
[17:29:42.688]                     })
[17:29:42.688]                   }
[17:29:42.688]                   ...future.strategy.old <- future::plan("list")
[17:29:42.688]                   options(future.plan = NULL)
[17:29:42.688]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.688]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.688]                 }
[17:29:42.688]                 ...future.workdir <- getwd()
[17:29:42.688]             }
[17:29:42.688]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.688]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.688]         }
[17:29:42.688]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.688]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.688]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.688]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.688]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.688]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.688]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.688]             base::names(...future.oldOptions))
[17:29:42.688]     }
[17:29:42.688]     if (FALSE) {
[17:29:42.688]     }
[17:29:42.688]     else {
[17:29:42.688]         if (TRUE) {
[17:29:42.688]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.688]                 open = "w")
[17:29:42.688]         }
[17:29:42.688]         else {
[17:29:42.688]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.688]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.688]         }
[17:29:42.688]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.688]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.688]             base::sink(type = "output", split = FALSE)
[17:29:42.688]             base::close(...future.stdout)
[17:29:42.688]         }, add = TRUE)
[17:29:42.688]     }
[17:29:42.688]     ...future.frame <- base::sys.nframe()
[17:29:42.688]     ...future.conditions <- base::list()
[17:29:42.688]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.688]     if (FALSE) {
[17:29:42.688]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.688]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.688]     }
[17:29:42.688]     ...future.result <- base::tryCatch({
[17:29:42.688]         base::withCallingHandlers({
[17:29:42.688]             ...future.value <- base::withVisible(base::local({
[17:29:42.688]                 sample(x, size = 1L)
[17:29:42.688]             }))
[17:29:42.688]             future::FutureResult(value = ...future.value$value, 
[17:29:42.688]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.688]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.688]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.688]                     ...future.globalenv.names))
[17:29:42.688]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.688]         }, condition = base::local({
[17:29:42.688]             c <- base::c
[17:29:42.688]             inherits <- base::inherits
[17:29:42.688]             invokeRestart <- base::invokeRestart
[17:29:42.688]             length <- base::length
[17:29:42.688]             list <- base::list
[17:29:42.688]             seq.int <- base::seq.int
[17:29:42.688]             signalCondition <- base::signalCondition
[17:29:42.688]             sys.calls <- base::sys.calls
[17:29:42.688]             `[[` <- base::`[[`
[17:29:42.688]             `+` <- base::`+`
[17:29:42.688]             `<<-` <- base::`<<-`
[17:29:42.688]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.688]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.688]                   3L)]
[17:29:42.688]             }
[17:29:42.688]             function(cond) {
[17:29:42.688]                 is_error <- inherits(cond, "error")
[17:29:42.688]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.688]                   NULL)
[17:29:42.688]                 if (is_error) {
[17:29:42.688]                   sessionInformation <- function() {
[17:29:42.688]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.688]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.688]                       search = base::search(), system = base::Sys.info())
[17:29:42.688]                   }
[17:29:42.688]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.688]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.688]                     cond$call), session = sessionInformation(), 
[17:29:42.688]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.688]                   signalCondition(cond)
[17:29:42.688]                 }
[17:29:42.688]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.688]                 "immediateCondition"))) {
[17:29:42.688]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.688]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.688]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.688]                   if (TRUE && !signal) {
[17:29:42.688]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.688]                     {
[17:29:42.688]                       inherits <- base::inherits
[17:29:42.688]                       invokeRestart <- base::invokeRestart
[17:29:42.688]                       is.null <- base::is.null
[17:29:42.688]                       muffled <- FALSE
[17:29:42.688]                       if (inherits(cond, "message")) {
[17:29:42.688]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.688]                         if (muffled) 
[17:29:42.688]                           invokeRestart("muffleMessage")
[17:29:42.688]                       }
[17:29:42.688]                       else if (inherits(cond, "warning")) {
[17:29:42.688]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.688]                         if (muffled) 
[17:29:42.688]                           invokeRestart("muffleWarning")
[17:29:42.688]                       }
[17:29:42.688]                       else if (inherits(cond, "condition")) {
[17:29:42.688]                         if (!is.null(pattern)) {
[17:29:42.688]                           computeRestarts <- base::computeRestarts
[17:29:42.688]                           grepl <- base::grepl
[17:29:42.688]                           restarts <- computeRestarts(cond)
[17:29:42.688]                           for (restart in restarts) {
[17:29:42.688]                             name <- restart$name
[17:29:42.688]                             if (is.null(name)) 
[17:29:42.688]                               next
[17:29:42.688]                             if (!grepl(pattern, name)) 
[17:29:42.688]                               next
[17:29:42.688]                             invokeRestart(restart)
[17:29:42.688]                             muffled <- TRUE
[17:29:42.688]                             break
[17:29:42.688]                           }
[17:29:42.688]                         }
[17:29:42.688]                       }
[17:29:42.688]                       invisible(muffled)
[17:29:42.688]                     }
[17:29:42.688]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.688]                   }
[17:29:42.688]                 }
[17:29:42.688]                 else {
[17:29:42.688]                   if (TRUE) {
[17:29:42.688]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.688]                     {
[17:29:42.688]                       inherits <- base::inherits
[17:29:42.688]                       invokeRestart <- base::invokeRestart
[17:29:42.688]                       is.null <- base::is.null
[17:29:42.688]                       muffled <- FALSE
[17:29:42.688]                       if (inherits(cond, "message")) {
[17:29:42.688]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.688]                         if (muffled) 
[17:29:42.688]                           invokeRestart("muffleMessage")
[17:29:42.688]                       }
[17:29:42.688]                       else if (inherits(cond, "warning")) {
[17:29:42.688]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.688]                         if (muffled) 
[17:29:42.688]                           invokeRestart("muffleWarning")
[17:29:42.688]                       }
[17:29:42.688]                       else if (inherits(cond, "condition")) {
[17:29:42.688]                         if (!is.null(pattern)) {
[17:29:42.688]                           computeRestarts <- base::computeRestarts
[17:29:42.688]                           grepl <- base::grepl
[17:29:42.688]                           restarts <- computeRestarts(cond)
[17:29:42.688]                           for (restart in restarts) {
[17:29:42.688]                             name <- restart$name
[17:29:42.688]                             if (is.null(name)) 
[17:29:42.688]                               next
[17:29:42.688]                             if (!grepl(pattern, name)) 
[17:29:42.688]                               next
[17:29:42.688]                             invokeRestart(restart)
[17:29:42.688]                             muffled <- TRUE
[17:29:42.688]                             break
[17:29:42.688]                           }
[17:29:42.688]                         }
[17:29:42.688]                       }
[17:29:42.688]                       invisible(muffled)
[17:29:42.688]                     }
[17:29:42.688]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.688]                   }
[17:29:42.688]                 }
[17:29:42.688]             }
[17:29:42.688]         }))
[17:29:42.688]     }, error = function(ex) {
[17:29:42.688]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.688]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.688]                 ...future.rng), started = ...future.startTime, 
[17:29:42.688]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.688]             version = "1.8"), class = "FutureResult")
[17:29:42.688]     }, finally = {
[17:29:42.688]         if (!identical(...future.workdir, getwd())) 
[17:29:42.688]             setwd(...future.workdir)
[17:29:42.688]         {
[17:29:42.688]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.688]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.688]             }
[17:29:42.688]             base::options(...future.oldOptions)
[17:29:42.688]             if (.Platform$OS.type == "windows") {
[17:29:42.688]                 old_names <- names(...future.oldEnvVars)
[17:29:42.688]                 envs <- base::Sys.getenv()
[17:29:42.688]                 names <- names(envs)
[17:29:42.688]                 common <- intersect(names, old_names)
[17:29:42.688]                 added <- setdiff(names, old_names)
[17:29:42.688]                 removed <- setdiff(old_names, names)
[17:29:42.688]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.688]                   envs[common]]
[17:29:42.688]                 NAMES <- toupper(changed)
[17:29:42.688]                 args <- list()
[17:29:42.688]                 for (kk in seq_along(NAMES)) {
[17:29:42.688]                   name <- changed[[kk]]
[17:29:42.688]                   NAME <- NAMES[[kk]]
[17:29:42.688]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.688]                     next
[17:29:42.688]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.688]                 }
[17:29:42.688]                 NAMES <- toupper(added)
[17:29:42.688]                 for (kk in seq_along(NAMES)) {
[17:29:42.688]                   name <- added[[kk]]
[17:29:42.688]                   NAME <- NAMES[[kk]]
[17:29:42.688]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.688]                     next
[17:29:42.688]                   args[[name]] <- ""
[17:29:42.688]                 }
[17:29:42.688]                 NAMES <- toupper(removed)
[17:29:42.688]                 for (kk in seq_along(NAMES)) {
[17:29:42.688]                   name <- removed[[kk]]
[17:29:42.688]                   NAME <- NAMES[[kk]]
[17:29:42.688]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.688]                     next
[17:29:42.688]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.688]                 }
[17:29:42.688]                 if (length(args) > 0) 
[17:29:42.688]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.688]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.688]             }
[17:29:42.688]             else {
[17:29:42.688]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.688]             }
[17:29:42.688]             {
[17:29:42.688]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.688]                   0L) {
[17:29:42.688]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.688]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.688]                   base::options(opts)
[17:29:42.688]                 }
[17:29:42.688]                 {
[17:29:42.688]                   {
[17:29:42.688]                     base::assign(".Random.seed", c(10407L, 856904683L, 
[17:29:42.688]                     -1350766746L, 671031386L, -594096583L, 1128026338L, 
[17:29:42.688]                     1353014223L), envir = base::globalenv(), 
[17:29:42.688]                       inherits = FALSE)
[17:29:42.688]                     NULL
[17:29:42.688]                   }
[17:29:42.688]                   options(future.plan = NULL)
[17:29:42.688]                   if (is.na(NA_character_)) 
[17:29:42.688]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.688]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.688]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.688]                     .init = FALSE)
[17:29:42.688]                 }
[17:29:42.688]             }
[17:29:42.688]         }
[17:29:42.688]     })
[17:29:42.688]     if (TRUE) {
[17:29:42.688]         base::sink(type = "output", split = FALSE)
[17:29:42.688]         if (TRUE) {
[17:29:42.688]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.688]         }
[17:29:42.688]         else {
[17:29:42.688]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.688]         }
[17:29:42.688]         base::close(...future.stdout)
[17:29:42.688]         ...future.stdout <- NULL
[17:29:42.688]     }
[17:29:42.688]     ...future.result$conditions <- ...future.conditions
[17:29:42.688]     ...future.result$finished <- base::Sys.time()
[17:29:42.688]     ...future.result
[17:29:42.688] }
[17:29:42.694] assign_globals() ...
[17:29:42.694] List of 1
[17:29:42.694]  $ x: int [1:4] 0 1 2 3
[17:29:42.694]  - attr(*, "where")=List of 1
[17:29:42.694]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.694]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.694]  - attr(*, "resolved")= logi FALSE
[17:29:42.694]  - attr(*, "total_size")= int 133
[17:29:42.694]  - attr(*, "already-done")= logi TRUE
[17:29:42.699] - copied 'x' to environment
[17:29:42.699] assign_globals() ... done
[17:29:42.700] plan(): Setting new future strategy stack:
[17:29:42.700] List of future strategies:
[17:29:42.700] 1. sequential:
[17:29:42.700]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.700]    - tweaked: FALSE
[17:29:42.700]    - call: NULL
[17:29:42.701] plan(): nbrOfWorkers() = 1
[17:29:42.703] plan(): Setting new future strategy stack:
[17:29:42.703] List of future strategies:
[17:29:42.703] 1. sequential:
[17:29:42.703]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.703]    - tweaked: FALSE
[17:29:42.703]    - call: plan(strategy)
[17:29:42.704] plan(): nbrOfWorkers() = 1
[17:29:42.705] SequentialFuture started (and completed)
[17:29:42.705] - Launch lazy future ... done
[17:29:42.705] run() for 'SequentialFuture' ... done
[17:29:42.706] getGlobalsAndPackages() ...
[17:29:42.706] Searching for globals...
[17:29:42.708] - globals found: [3] '{', 'sample', 'x'
[17:29:42.709] Searching for globals ... DONE
[17:29:42.709] Resolving globals: FALSE
[17:29:42.710] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.710] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.711] - globals: [1] 'x'
[17:29:42.711] 
[17:29:42.711] getGlobalsAndPackages() ... DONE
[17:29:42.712] run() for 'Future' ...
[17:29:42.712] - state: 'created'
[17:29:42.712] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.713] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.713] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.713]   - Field: 'label'
[17:29:42.714]   - Field: 'local'
[17:29:42.714]   - Field: 'owner'
[17:29:42.714]   - Field: 'envir'
[17:29:42.714]   - Field: 'packages'
[17:29:42.715]   - Field: 'gc'
[17:29:42.715]   - Field: 'conditions'
[17:29:42.715]   - Field: 'expr'
[17:29:42.716]   - Field: 'uuid'
[17:29:42.716]   - Field: 'seed'
[17:29:42.716]   - Field: 'version'
[17:29:42.716]   - Field: 'result'
[17:29:42.717]   - Field: 'asynchronous'
[17:29:42.761]   - Field: 'calls'
[17:29:42.761]   - Field: 'globals'
[17:29:42.762]   - Field: 'stdout'
[17:29:42.762]   - Field: 'earlySignal'
[17:29:42.762]   - Field: 'lazy'
[17:29:42.763]   - Field: 'state'
[17:29:42.763] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.763] - Launch lazy future ...
[17:29:42.763] Packages needed by the future expression (n = 0): <none>
[17:29:42.764] Packages needed by future strategies (n = 0): <none>
[17:29:42.765] {
[17:29:42.765]     {
[17:29:42.765]         {
[17:29:42.765]             ...future.startTime <- base::Sys.time()
[17:29:42.765]             {
[17:29:42.765]                 {
[17:29:42.765]                   {
[17:29:42.765]                     base::local({
[17:29:42.765]                       has_future <- base::requireNamespace("future", 
[17:29:42.765]                         quietly = TRUE)
[17:29:42.765]                       if (has_future) {
[17:29:42.765]                         ns <- base::getNamespace("future")
[17:29:42.765]                         version <- ns[[".package"]][["version"]]
[17:29:42.765]                         if (is.null(version)) 
[17:29:42.765]                           version <- utils::packageVersion("future")
[17:29:42.765]                       }
[17:29:42.765]                       else {
[17:29:42.765]                         version <- NULL
[17:29:42.765]                       }
[17:29:42.765]                       if (!has_future || version < "1.8.0") {
[17:29:42.765]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.765]                           "", base::R.version$version.string), 
[17:29:42.765]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.765]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.765]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.765]                             "release", "version")], collapse = " "), 
[17:29:42.765]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.765]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.765]                           info)
[17:29:42.765]                         info <- base::paste(info, collapse = "; ")
[17:29:42.765]                         if (!has_future) {
[17:29:42.765]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.765]                             info)
[17:29:42.765]                         }
[17:29:42.765]                         else {
[17:29:42.765]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.765]                             info, version)
[17:29:42.765]                         }
[17:29:42.765]                         base::stop(msg)
[17:29:42.765]                       }
[17:29:42.765]                     })
[17:29:42.765]                   }
[17:29:42.765]                   ...future.strategy.old <- future::plan("list")
[17:29:42.765]                   options(future.plan = NULL)
[17:29:42.765]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.765]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.765]                 }
[17:29:42.765]                 ...future.workdir <- getwd()
[17:29:42.765]             }
[17:29:42.765]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.765]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.765]         }
[17:29:42.765]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.765]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.765]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.765]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.765]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.765]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.765]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.765]             base::names(...future.oldOptions))
[17:29:42.765]     }
[17:29:42.765]     if (FALSE) {
[17:29:42.765]     }
[17:29:42.765]     else {
[17:29:42.765]         if (TRUE) {
[17:29:42.765]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.765]                 open = "w")
[17:29:42.765]         }
[17:29:42.765]         else {
[17:29:42.765]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.765]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.765]         }
[17:29:42.765]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.765]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.765]             base::sink(type = "output", split = FALSE)
[17:29:42.765]             base::close(...future.stdout)
[17:29:42.765]         }, add = TRUE)
[17:29:42.765]     }
[17:29:42.765]     ...future.frame <- base::sys.nframe()
[17:29:42.765]     ...future.conditions <- base::list()
[17:29:42.765]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.765]     if (FALSE) {
[17:29:42.765]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.765]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.765]     }
[17:29:42.765]     ...future.result <- base::tryCatch({
[17:29:42.765]         base::withCallingHandlers({
[17:29:42.765]             ...future.value <- base::withVisible(base::local({
[17:29:42.765]                 sample(x, size = 1L)
[17:29:42.765]             }))
[17:29:42.765]             future::FutureResult(value = ...future.value$value, 
[17:29:42.765]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.765]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.765]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.765]                     ...future.globalenv.names))
[17:29:42.765]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.765]         }, condition = base::local({
[17:29:42.765]             c <- base::c
[17:29:42.765]             inherits <- base::inherits
[17:29:42.765]             invokeRestart <- base::invokeRestart
[17:29:42.765]             length <- base::length
[17:29:42.765]             list <- base::list
[17:29:42.765]             seq.int <- base::seq.int
[17:29:42.765]             signalCondition <- base::signalCondition
[17:29:42.765]             sys.calls <- base::sys.calls
[17:29:42.765]             `[[` <- base::`[[`
[17:29:42.765]             `+` <- base::`+`
[17:29:42.765]             `<<-` <- base::`<<-`
[17:29:42.765]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.765]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.765]                   3L)]
[17:29:42.765]             }
[17:29:42.765]             function(cond) {
[17:29:42.765]                 is_error <- inherits(cond, "error")
[17:29:42.765]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.765]                   NULL)
[17:29:42.765]                 if (is_error) {
[17:29:42.765]                   sessionInformation <- function() {
[17:29:42.765]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.765]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.765]                       search = base::search(), system = base::Sys.info())
[17:29:42.765]                   }
[17:29:42.765]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.765]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.765]                     cond$call), session = sessionInformation(), 
[17:29:42.765]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.765]                   signalCondition(cond)
[17:29:42.765]                 }
[17:29:42.765]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.765]                 "immediateCondition"))) {
[17:29:42.765]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.765]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.765]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.765]                   if (TRUE && !signal) {
[17:29:42.765]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.765]                     {
[17:29:42.765]                       inherits <- base::inherits
[17:29:42.765]                       invokeRestart <- base::invokeRestart
[17:29:42.765]                       is.null <- base::is.null
[17:29:42.765]                       muffled <- FALSE
[17:29:42.765]                       if (inherits(cond, "message")) {
[17:29:42.765]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.765]                         if (muffled) 
[17:29:42.765]                           invokeRestart("muffleMessage")
[17:29:42.765]                       }
[17:29:42.765]                       else if (inherits(cond, "warning")) {
[17:29:42.765]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.765]                         if (muffled) 
[17:29:42.765]                           invokeRestart("muffleWarning")
[17:29:42.765]                       }
[17:29:42.765]                       else if (inherits(cond, "condition")) {
[17:29:42.765]                         if (!is.null(pattern)) {
[17:29:42.765]                           computeRestarts <- base::computeRestarts
[17:29:42.765]                           grepl <- base::grepl
[17:29:42.765]                           restarts <- computeRestarts(cond)
[17:29:42.765]                           for (restart in restarts) {
[17:29:42.765]                             name <- restart$name
[17:29:42.765]                             if (is.null(name)) 
[17:29:42.765]                               next
[17:29:42.765]                             if (!grepl(pattern, name)) 
[17:29:42.765]                               next
[17:29:42.765]                             invokeRestart(restart)
[17:29:42.765]                             muffled <- TRUE
[17:29:42.765]                             break
[17:29:42.765]                           }
[17:29:42.765]                         }
[17:29:42.765]                       }
[17:29:42.765]                       invisible(muffled)
[17:29:42.765]                     }
[17:29:42.765]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.765]                   }
[17:29:42.765]                 }
[17:29:42.765]                 else {
[17:29:42.765]                   if (TRUE) {
[17:29:42.765]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.765]                     {
[17:29:42.765]                       inherits <- base::inherits
[17:29:42.765]                       invokeRestart <- base::invokeRestart
[17:29:42.765]                       is.null <- base::is.null
[17:29:42.765]                       muffled <- FALSE
[17:29:42.765]                       if (inherits(cond, "message")) {
[17:29:42.765]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.765]                         if (muffled) 
[17:29:42.765]                           invokeRestart("muffleMessage")
[17:29:42.765]                       }
[17:29:42.765]                       else if (inherits(cond, "warning")) {
[17:29:42.765]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.765]                         if (muffled) 
[17:29:42.765]                           invokeRestart("muffleWarning")
[17:29:42.765]                       }
[17:29:42.765]                       else if (inherits(cond, "condition")) {
[17:29:42.765]                         if (!is.null(pattern)) {
[17:29:42.765]                           computeRestarts <- base::computeRestarts
[17:29:42.765]                           grepl <- base::grepl
[17:29:42.765]                           restarts <- computeRestarts(cond)
[17:29:42.765]                           for (restart in restarts) {
[17:29:42.765]                             name <- restart$name
[17:29:42.765]                             if (is.null(name)) 
[17:29:42.765]                               next
[17:29:42.765]                             if (!grepl(pattern, name)) 
[17:29:42.765]                               next
[17:29:42.765]                             invokeRestart(restart)
[17:29:42.765]                             muffled <- TRUE
[17:29:42.765]                             break
[17:29:42.765]                           }
[17:29:42.765]                         }
[17:29:42.765]                       }
[17:29:42.765]                       invisible(muffled)
[17:29:42.765]                     }
[17:29:42.765]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.765]                   }
[17:29:42.765]                 }
[17:29:42.765]             }
[17:29:42.765]         }))
[17:29:42.765]     }, error = function(ex) {
[17:29:42.765]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.765]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.765]                 ...future.rng), started = ...future.startTime, 
[17:29:42.765]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.765]             version = "1.8"), class = "FutureResult")
[17:29:42.765]     }, finally = {
[17:29:42.765]         if (!identical(...future.workdir, getwd())) 
[17:29:42.765]             setwd(...future.workdir)
[17:29:42.765]         {
[17:29:42.765]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.765]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.765]             }
[17:29:42.765]             base::options(...future.oldOptions)
[17:29:42.765]             if (.Platform$OS.type == "windows") {
[17:29:42.765]                 old_names <- names(...future.oldEnvVars)
[17:29:42.765]                 envs <- base::Sys.getenv()
[17:29:42.765]                 names <- names(envs)
[17:29:42.765]                 common <- intersect(names, old_names)
[17:29:42.765]                 added <- setdiff(names, old_names)
[17:29:42.765]                 removed <- setdiff(old_names, names)
[17:29:42.765]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.765]                   envs[common]]
[17:29:42.765]                 NAMES <- toupper(changed)
[17:29:42.765]                 args <- list()
[17:29:42.765]                 for (kk in seq_along(NAMES)) {
[17:29:42.765]                   name <- changed[[kk]]
[17:29:42.765]                   NAME <- NAMES[[kk]]
[17:29:42.765]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.765]                     next
[17:29:42.765]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.765]                 }
[17:29:42.765]                 NAMES <- toupper(added)
[17:29:42.765]                 for (kk in seq_along(NAMES)) {
[17:29:42.765]                   name <- added[[kk]]
[17:29:42.765]                   NAME <- NAMES[[kk]]
[17:29:42.765]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.765]                     next
[17:29:42.765]                   args[[name]] <- ""
[17:29:42.765]                 }
[17:29:42.765]                 NAMES <- toupper(removed)
[17:29:42.765]                 for (kk in seq_along(NAMES)) {
[17:29:42.765]                   name <- removed[[kk]]
[17:29:42.765]                   NAME <- NAMES[[kk]]
[17:29:42.765]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.765]                     next
[17:29:42.765]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.765]                 }
[17:29:42.765]                 if (length(args) > 0) 
[17:29:42.765]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.765]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.765]             }
[17:29:42.765]             else {
[17:29:42.765]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.765]             }
[17:29:42.765]             {
[17:29:42.765]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.765]                   0L) {
[17:29:42.765]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.765]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.765]                   base::options(opts)
[17:29:42.765]                 }
[17:29:42.765]                 {
[17:29:42.765]                   {
[17:29:42.765]                     base::assign(".Random.seed", c(10407L, 671031386L, 
[17:29:42.765]                     -153206494L, -2079745448L, 1353014223L, -823645377L, 
[17:29:42.765]                     12183680L), envir = base::globalenv(), inherits = FALSE)
[17:29:42.765]                     NULL
[17:29:42.765]                   }
[17:29:42.765]                   options(future.plan = NULL)
[17:29:42.765]                   if (is.na(NA_character_)) 
[17:29:42.765]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.765]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.765]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.765]                     .init = FALSE)
[17:29:42.765]                 }
[17:29:42.765]             }
[17:29:42.765]         }
[17:29:42.765]     })
[17:29:42.765]     if (TRUE) {
[17:29:42.765]         base::sink(type = "output", split = FALSE)
[17:29:42.765]         if (TRUE) {
[17:29:42.765]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.765]         }
[17:29:42.765]         else {
[17:29:42.765]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.765]         }
[17:29:42.765]         base::close(...future.stdout)
[17:29:42.765]         ...future.stdout <- NULL
[17:29:42.765]     }
[17:29:42.765]     ...future.result$conditions <- ...future.conditions
[17:29:42.765]     ...future.result$finished <- base::Sys.time()
[17:29:42.765]     ...future.result
[17:29:42.765] }
[17:29:42.770] assign_globals() ...
[17:29:42.771] List of 1
[17:29:42.771]  $ x: int [1:4] 0 1 2 3
[17:29:42.771]  - attr(*, "where")=List of 1
[17:29:42.771]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.771]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.771]  - attr(*, "resolved")= logi FALSE
[17:29:42.771]  - attr(*, "total_size")= int 133
[17:29:42.771]  - attr(*, "already-done")= logi TRUE
[17:29:42.776] - copied 'x' to environment
[17:29:42.777] assign_globals() ... done
[17:29:42.777] plan(): Setting new future strategy stack:
[17:29:42.778] List of future strategies:
[17:29:42.778] 1. sequential:
[17:29:42.778]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.778]    - tweaked: FALSE
[17:29:42.778]    - call: NULL
[17:29:42.779] plan(): nbrOfWorkers() = 1
[17:29:42.781] plan(): Setting new future strategy stack:
[17:29:42.781] List of future strategies:
[17:29:42.781] 1. sequential:
[17:29:42.781]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.781]    - tweaked: FALSE
[17:29:42.781]    - call: plan(strategy)
[17:29:42.783] plan(): nbrOfWorkers() = 1
[17:29:42.783] SequentialFuture started (and completed)
[17:29:42.783] - Launch lazy future ... done
[17:29:42.784] run() for 'SequentialFuture' ... done
[17:29:42.785] getGlobalsAndPackages() ...
[17:29:42.785] Searching for globals...
[17:29:42.787] - globals found: [3] '{', 'sample', 'x'
[17:29:42.788] Searching for globals ... DONE
[17:29:42.788] Resolving globals: FALSE
[17:29:42.789] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.789] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.790] - globals: [1] 'x'
[17:29:42.790] 
[17:29:42.790] getGlobalsAndPackages() ... DONE
[17:29:42.791] run() for 'Future' ...
[17:29:42.791] - state: 'created'
[17:29:42.792] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.792] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.793] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.793]   - Field: 'label'
[17:29:42.793]   - Field: 'local'
[17:29:42.794]   - Field: 'owner'
[17:29:42.794]   - Field: 'envir'
[17:29:42.794]   - Field: 'packages'
[17:29:42.795]   - Field: 'gc'
[17:29:42.795]   - Field: 'conditions'
[17:29:42.795]   - Field: 'expr'
[17:29:42.796]   - Field: 'uuid'
[17:29:42.796]   - Field: 'seed'
[17:29:42.796]   - Field: 'version'
[17:29:42.796]   - Field: 'result'
[17:29:42.797]   - Field: 'asynchronous'
[17:29:42.797]   - Field: 'calls'
[17:29:42.797]   - Field: 'globals'
[17:29:42.798]   - Field: 'stdout'
[17:29:42.798]   - Field: 'earlySignal'
[17:29:42.798]   - Field: 'lazy'
[17:29:42.799]   - Field: 'state'
[17:29:42.799] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.799] - Launch lazy future ...
[17:29:42.800] Packages needed by the future expression (n = 0): <none>
[17:29:42.800] Packages needed by future strategies (n = 0): <none>
[17:29:42.801] {
[17:29:42.801]     {
[17:29:42.801]         {
[17:29:42.801]             ...future.startTime <- base::Sys.time()
[17:29:42.801]             {
[17:29:42.801]                 {
[17:29:42.801]                   {
[17:29:42.801]                     base::local({
[17:29:42.801]                       has_future <- base::requireNamespace("future", 
[17:29:42.801]                         quietly = TRUE)
[17:29:42.801]                       if (has_future) {
[17:29:42.801]                         ns <- base::getNamespace("future")
[17:29:42.801]                         version <- ns[[".package"]][["version"]]
[17:29:42.801]                         if (is.null(version)) 
[17:29:42.801]                           version <- utils::packageVersion("future")
[17:29:42.801]                       }
[17:29:42.801]                       else {
[17:29:42.801]                         version <- NULL
[17:29:42.801]                       }
[17:29:42.801]                       if (!has_future || version < "1.8.0") {
[17:29:42.801]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.801]                           "", base::R.version$version.string), 
[17:29:42.801]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.801]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.801]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.801]                             "release", "version")], collapse = " "), 
[17:29:42.801]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.801]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.801]                           info)
[17:29:42.801]                         info <- base::paste(info, collapse = "; ")
[17:29:42.801]                         if (!has_future) {
[17:29:42.801]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.801]                             info)
[17:29:42.801]                         }
[17:29:42.801]                         else {
[17:29:42.801]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.801]                             info, version)
[17:29:42.801]                         }
[17:29:42.801]                         base::stop(msg)
[17:29:42.801]                       }
[17:29:42.801]                     })
[17:29:42.801]                   }
[17:29:42.801]                   ...future.strategy.old <- future::plan("list")
[17:29:42.801]                   options(future.plan = NULL)
[17:29:42.801]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.801]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.801]                 }
[17:29:42.801]                 ...future.workdir <- getwd()
[17:29:42.801]             }
[17:29:42.801]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.801]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.801]         }
[17:29:42.801]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.801]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.801]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.801]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.801]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.801]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.801]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.801]             base::names(...future.oldOptions))
[17:29:42.801]     }
[17:29:42.801]     if (FALSE) {
[17:29:42.801]     }
[17:29:42.801]     else {
[17:29:42.801]         if (TRUE) {
[17:29:42.801]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.801]                 open = "w")
[17:29:42.801]         }
[17:29:42.801]         else {
[17:29:42.801]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.801]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.801]         }
[17:29:42.801]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.801]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.801]             base::sink(type = "output", split = FALSE)
[17:29:42.801]             base::close(...future.stdout)
[17:29:42.801]         }, add = TRUE)
[17:29:42.801]     }
[17:29:42.801]     ...future.frame <- base::sys.nframe()
[17:29:42.801]     ...future.conditions <- base::list()
[17:29:42.801]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.801]     if (FALSE) {
[17:29:42.801]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.801]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.801]     }
[17:29:42.801]     ...future.result <- base::tryCatch({
[17:29:42.801]         base::withCallingHandlers({
[17:29:42.801]             ...future.value <- base::withVisible(base::local({
[17:29:42.801]                 sample(x, size = 1L)
[17:29:42.801]             }))
[17:29:42.801]             future::FutureResult(value = ...future.value$value, 
[17:29:42.801]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.801]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.801]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.801]                     ...future.globalenv.names))
[17:29:42.801]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.801]         }, condition = base::local({
[17:29:42.801]             c <- base::c
[17:29:42.801]             inherits <- base::inherits
[17:29:42.801]             invokeRestart <- base::invokeRestart
[17:29:42.801]             length <- base::length
[17:29:42.801]             list <- base::list
[17:29:42.801]             seq.int <- base::seq.int
[17:29:42.801]             signalCondition <- base::signalCondition
[17:29:42.801]             sys.calls <- base::sys.calls
[17:29:42.801]             `[[` <- base::`[[`
[17:29:42.801]             `+` <- base::`+`
[17:29:42.801]             `<<-` <- base::`<<-`
[17:29:42.801]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.801]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.801]                   3L)]
[17:29:42.801]             }
[17:29:42.801]             function(cond) {
[17:29:42.801]                 is_error <- inherits(cond, "error")
[17:29:42.801]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.801]                   NULL)
[17:29:42.801]                 if (is_error) {
[17:29:42.801]                   sessionInformation <- function() {
[17:29:42.801]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.801]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.801]                       search = base::search(), system = base::Sys.info())
[17:29:42.801]                   }
[17:29:42.801]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.801]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.801]                     cond$call), session = sessionInformation(), 
[17:29:42.801]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.801]                   signalCondition(cond)
[17:29:42.801]                 }
[17:29:42.801]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.801]                 "immediateCondition"))) {
[17:29:42.801]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.801]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.801]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.801]                   if (TRUE && !signal) {
[17:29:42.801]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.801]                     {
[17:29:42.801]                       inherits <- base::inherits
[17:29:42.801]                       invokeRestart <- base::invokeRestart
[17:29:42.801]                       is.null <- base::is.null
[17:29:42.801]                       muffled <- FALSE
[17:29:42.801]                       if (inherits(cond, "message")) {
[17:29:42.801]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.801]                         if (muffled) 
[17:29:42.801]                           invokeRestart("muffleMessage")
[17:29:42.801]                       }
[17:29:42.801]                       else if (inherits(cond, "warning")) {
[17:29:42.801]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.801]                         if (muffled) 
[17:29:42.801]                           invokeRestart("muffleWarning")
[17:29:42.801]                       }
[17:29:42.801]                       else if (inherits(cond, "condition")) {
[17:29:42.801]                         if (!is.null(pattern)) {
[17:29:42.801]                           computeRestarts <- base::computeRestarts
[17:29:42.801]                           grepl <- base::grepl
[17:29:42.801]                           restarts <- computeRestarts(cond)
[17:29:42.801]                           for (restart in restarts) {
[17:29:42.801]                             name <- restart$name
[17:29:42.801]                             if (is.null(name)) 
[17:29:42.801]                               next
[17:29:42.801]                             if (!grepl(pattern, name)) 
[17:29:42.801]                               next
[17:29:42.801]                             invokeRestart(restart)
[17:29:42.801]                             muffled <- TRUE
[17:29:42.801]                             break
[17:29:42.801]                           }
[17:29:42.801]                         }
[17:29:42.801]                       }
[17:29:42.801]                       invisible(muffled)
[17:29:42.801]                     }
[17:29:42.801]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.801]                   }
[17:29:42.801]                 }
[17:29:42.801]                 else {
[17:29:42.801]                   if (TRUE) {
[17:29:42.801]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.801]                     {
[17:29:42.801]                       inherits <- base::inherits
[17:29:42.801]                       invokeRestart <- base::invokeRestart
[17:29:42.801]                       is.null <- base::is.null
[17:29:42.801]                       muffled <- FALSE
[17:29:42.801]                       if (inherits(cond, "message")) {
[17:29:42.801]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.801]                         if (muffled) 
[17:29:42.801]                           invokeRestart("muffleMessage")
[17:29:42.801]                       }
[17:29:42.801]                       else if (inherits(cond, "warning")) {
[17:29:42.801]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.801]                         if (muffled) 
[17:29:42.801]                           invokeRestart("muffleWarning")
[17:29:42.801]                       }
[17:29:42.801]                       else if (inherits(cond, "condition")) {
[17:29:42.801]                         if (!is.null(pattern)) {
[17:29:42.801]                           computeRestarts <- base::computeRestarts
[17:29:42.801]                           grepl <- base::grepl
[17:29:42.801]                           restarts <- computeRestarts(cond)
[17:29:42.801]                           for (restart in restarts) {
[17:29:42.801]                             name <- restart$name
[17:29:42.801]                             if (is.null(name)) 
[17:29:42.801]                               next
[17:29:42.801]                             if (!grepl(pattern, name)) 
[17:29:42.801]                               next
[17:29:42.801]                             invokeRestart(restart)
[17:29:42.801]                             muffled <- TRUE
[17:29:42.801]                             break
[17:29:42.801]                           }
[17:29:42.801]                         }
[17:29:42.801]                       }
[17:29:42.801]                       invisible(muffled)
[17:29:42.801]                     }
[17:29:42.801]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.801]                   }
[17:29:42.801]                 }
[17:29:42.801]             }
[17:29:42.801]         }))
[17:29:42.801]     }, error = function(ex) {
[17:29:42.801]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.801]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.801]                 ...future.rng), started = ...future.startTime, 
[17:29:42.801]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.801]             version = "1.8"), class = "FutureResult")
[17:29:42.801]     }, finally = {
[17:29:42.801]         if (!identical(...future.workdir, getwd())) 
[17:29:42.801]             setwd(...future.workdir)
[17:29:42.801]         {
[17:29:42.801]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.801]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.801]             }
[17:29:42.801]             base::options(...future.oldOptions)
[17:29:42.801]             if (.Platform$OS.type == "windows") {
[17:29:42.801]                 old_names <- names(...future.oldEnvVars)
[17:29:42.801]                 envs <- base::Sys.getenv()
[17:29:42.801]                 names <- names(envs)
[17:29:42.801]                 common <- intersect(names, old_names)
[17:29:42.801]                 added <- setdiff(names, old_names)
[17:29:42.801]                 removed <- setdiff(old_names, names)
[17:29:42.801]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.801]                   envs[common]]
[17:29:42.801]                 NAMES <- toupper(changed)
[17:29:42.801]                 args <- list()
[17:29:42.801]                 for (kk in seq_along(NAMES)) {
[17:29:42.801]                   name <- changed[[kk]]
[17:29:42.801]                   NAME <- NAMES[[kk]]
[17:29:42.801]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.801]                     next
[17:29:42.801]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.801]                 }
[17:29:42.801]                 NAMES <- toupper(added)
[17:29:42.801]                 for (kk in seq_along(NAMES)) {
[17:29:42.801]                   name <- added[[kk]]
[17:29:42.801]                   NAME <- NAMES[[kk]]
[17:29:42.801]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.801]                     next
[17:29:42.801]                   args[[name]] <- ""
[17:29:42.801]                 }
[17:29:42.801]                 NAMES <- toupper(removed)
[17:29:42.801]                 for (kk in seq_along(NAMES)) {
[17:29:42.801]                   name <- removed[[kk]]
[17:29:42.801]                   NAME <- NAMES[[kk]]
[17:29:42.801]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.801]                     next
[17:29:42.801]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.801]                 }
[17:29:42.801]                 if (length(args) > 0) 
[17:29:42.801]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.801]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.801]             }
[17:29:42.801]             else {
[17:29:42.801]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.801]             }
[17:29:42.801]             {
[17:29:42.801]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.801]                   0L) {
[17:29:42.801]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.801]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.801]                   base::options(opts)
[17:29:42.801]                 }
[17:29:42.801]                 {
[17:29:42.801]                   {
[17:29:42.801]                     base::assign(".Random.seed", c(10407L, -2079745448L, 
[17:29:42.801]                     1207177463L, 914861718L, 12183680L, 475207752L, 
[17:29:42.801]                     -1525619580L), envir = base::globalenv(), 
[17:29:42.801]                       inherits = FALSE)
[17:29:42.801]                     NULL
[17:29:42.801]                   }
[17:29:42.801]                   options(future.plan = NULL)
[17:29:42.801]                   if (is.na(NA_character_)) 
[17:29:42.801]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.801]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.801]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.801]                     .init = FALSE)
[17:29:42.801]                 }
[17:29:42.801]             }
[17:29:42.801]         }
[17:29:42.801]     })
[17:29:42.801]     if (TRUE) {
[17:29:42.801]         base::sink(type = "output", split = FALSE)
[17:29:42.801]         if (TRUE) {
[17:29:42.801]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.801]         }
[17:29:42.801]         else {
[17:29:42.801]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.801]         }
[17:29:42.801]         base::close(...future.stdout)
[17:29:42.801]         ...future.stdout <- NULL
[17:29:42.801]     }
[17:29:42.801]     ...future.result$conditions <- ...future.conditions
[17:29:42.801]     ...future.result$finished <- base::Sys.time()
[17:29:42.801]     ...future.result
[17:29:42.801] }
[17:29:42.807] assign_globals() ...
[17:29:42.808] List of 1
[17:29:42.808]  $ x: int [1:4] 0 1 2 3
[17:29:42.808]  - attr(*, "where")=List of 1
[17:29:42.808]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.808]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.808]  - attr(*, "resolved")= logi FALSE
[17:29:42.808]  - attr(*, "total_size")= int 133
[17:29:42.808]  - attr(*, "already-done")= logi TRUE
[17:29:42.813] - copied 'x' to environment
[17:29:42.813] assign_globals() ... done
[17:29:42.814] plan(): Setting new future strategy stack:
[17:29:42.814] List of future strategies:
[17:29:42.814] 1. sequential:
[17:29:42.814]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.814]    - tweaked: FALSE
[17:29:42.814]    - call: NULL
[17:29:42.815] plan(): nbrOfWorkers() = 1
[17:29:42.817] plan(): Setting new future strategy stack:
[17:29:42.818] List of future strategies:
[17:29:42.818] 1. sequential:
[17:29:42.818]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.818]    - tweaked: FALSE
[17:29:42.818]    - call: plan(strategy)
[17:29:42.819] plan(): nbrOfWorkers() = 1
[17:29:42.819] SequentialFuture started (and completed)
[17:29:42.819] - Launch lazy future ... done
[17:29:42.820] run() for 'SequentialFuture' ... done
[17:29:42.821] Future state: 'finished'
[17:29:42.821] signalConditions() ...
[17:29:42.821]  - include = 'condition'
[17:29:42.822]  - exclude = 'immediateCondition'
[17:29:42.822]  - resignal = TRUE
[17:29:42.822]  - Number of conditions: 1
[17:29:42.822]  - Condition #1: 'RngFutureError', 'FutureError', 'error', 'RngFutureCondition', 'FutureCondition', 'condition'
[17:29:42.823] signalConditions() ... done
<RngFutureError: UNRELIABLE VALUE: Future ('fsample_1-218749') 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: 2c1cd68a-e2b2-865b-47e6-443c72d65b1c


DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
SequentialFuture:
Label: 'fsample_1-218749'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: FALSE
Local evaluation: TRUE
Environment: 0x000001add7f64370
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Conditions captured: [n=1] 'RngFutureError'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'

DEBUG: END TROUBLESHOOTING HELP
[17:29:42.825] getGlobalsAndPackages() ...
[17:29:42.826] Searching for globals...
[17:29:42.828] - globals found: [3] '{', 'sample', 'x'
[17:29:42.828] Searching for globals ... DONE
[17:29:42.829] Resolving globals: FALSE
[17:29:42.829] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.830] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.830] - globals: [1] 'x'
[17:29:42.831] 
[17:29:42.831] getGlobalsAndPackages() ... DONE
[17:29:42.832] run() for 'Future' ...
[17:29:42.832] - state: 'created'
[17:29:42.832] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.833] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.833] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.834]   - Field: 'label'
[17:29:42.834]   - Field: 'local'
[17:29:42.834]   - Field: 'owner'
[17:29:42.835]   - Field: 'envir'
[17:29:42.835]   - Field: 'packages'
[17:29:42.835]   - Field: 'gc'
[17:29:42.836]   - Field: 'conditions'
[17:29:42.836]   - Field: 'expr'
[17:29:42.836]   - Field: 'uuid'
[17:29:42.837]   - Field: 'seed'
[17:29:42.837]   - Field: 'version'
[17:29:42.837]   - Field: 'result'
[17:29:42.838]   - Field: 'asynchronous'
[17:29:42.838]   - Field: 'calls'
[17:29:42.838]   - Field: 'globals'
[17:29:42.839]   - Field: 'stdout'
[17:29:42.839]   - Field: 'earlySignal'
[17:29:42.839]   - Field: 'lazy'
[17:29:42.840]   - Field: 'state'
[17:29:42.840] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.840] - Launch lazy future ...
[17:29:42.841] Packages needed by the future expression (n = 0): <none>
[17:29:42.841] Packages needed by future strategies (n = 0): <none>
[17:29:42.842] {
[17:29:42.842]     {
[17:29:42.842]         {
[17:29:42.842]             ...future.startTime <- base::Sys.time()
[17:29:42.842]             {
[17:29:42.842]                 {
[17:29:42.842]                   {
[17:29:42.842]                     base::local({
[17:29:42.842]                       has_future <- base::requireNamespace("future", 
[17:29:42.842]                         quietly = TRUE)
[17:29:42.842]                       if (has_future) {
[17:29:42.842]                         ns <- base::getNamespace("future")
[17:29:42.842]                         version <- ns[[".package"]][["version"]]
[17:29:42.842]                         if (is.null(version)) 
[17:29:42.842]                           version <- utils::packageVersion("future")
[17:29:42.842]                       }
[17:29:42.842]                       else {
[17:29:42.842]                         version <- NULL
[17:29:42.842]                       }
[17:29:42.842]                       if (!has_future || version < "1.8.0") {
[17:29:42.842]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.842]                           "", base::R.version$version.string), 
[17:29:42.842]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.842]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.842]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.842]                             "release", "version")], collapse = " "), 
[17:29:42.842]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.842]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.842]                           info)
[17:29:42.842]                         info <- base::paste(info, collapse = "; ")
[17:29:42.842]                         if (!has_future) {
[17:29:42.842]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.842]                             info)
[17:29:42.842]                         }
[17:29:42.842]                         else {
[17:29:42.842]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.842]                             info, version)
[17:29:42.842]                         }
[17:29:42.842]                         base::stop(msg)
[17:29:42.842]                       }
[17:29:42.842]                     })
[17:29:42.842]                   }
[17:29:42.842]                   ...future.strategy.old <- future::plan("list")
[17:29:42.842]                   options(future.plan = NULL)
[17:29:42.842]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.842]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.842]                 }
[17:29:42.842]                 ...future.workdir <- getwd()
[17:29:42.842]             }
[17:29:42.842]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.842]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.842]         }
[17:29:42.842]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.842]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.842]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.842]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.842]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.842]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.842]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.842]             base::names(...future.oldOptions))
[17:29:42.842]     }
[17:29:42.842]     if (FALSE) {
[17:29:42.842]     }
[17:29:42.842]     else {
[17:29:42.842]         if (TRUE) {
[17:29:42.842]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.842]                 open = "w")
[17:29:42.842]         }
[17:29:42.842]         else {
[17:29:42.842]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.842]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.842]         }
[17:29:42.842]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.842]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.842]             base::sink(type = "output", split = FALSE)
[17:29:42.842]             base::close(...future.stdout)
[17:29:42.842]         }, add = TRUE)
[17:29:42.842]     }
[17:29:42.842]     ...future.frame <- base::sys.nframe()
[17:29:42.842]     ...future.conditions <- base::list()
[17:29:42.842]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.842]     if (FALSE) {
[17:29:42.842]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.842]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.842]     }
[17:29:42.842]     ...future.result <- base::tryCatch({
[17:29:42.842]         base::withCallingHandlers({
[17:29:42.842]             ...future.value <- base::withVisible(base::local({
[17:29:42.842]                 sample(x, size = 1L)
[17:29:42.842]             }))
[17:29:42.842]             future::FutureResult(value = ...future.value$value, 
[17:29:42.842]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.842]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.842]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.842]                     ...future.globalenv.names))
[17:29:42.842]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.842]         }, condition = base::local({
[17:29:42.842]             c <- base::c
[17:29:42.842]             inherits <- base::inherits
[17:29:42.842]             invokeRestart <- base::invokeRestart
[17:29:42.842]             length <- base::length
[17:29:42.842]             list <- base::list
[17:29:42.842]             seq.int <- base::seq.int
[17:29:42.842]             signalCondition <- base::signalCondition
[17:29:42.842]             sys.calls <- base::sys.calls
[17:29:42.842]             `[[` <- base::`[[`
[17:29:42.842]             `+` <- base::`+`
[17:29:42.842]             `<<-` <- base::`<<-`
[17:29:42.842]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.842]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.842]                   3L)]
[17:29:42.842]             }
[17:29:42.842]             function(cond) {
[17:29:42.842]                 is_error <- inherits(cond, "error")
[17:29:42.842]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.842]                   NULL)
[17:29:42.842]                 if (is_error) {
[17:29:42.842]                   sessionInformation <- function() {
[17:29:42.842]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.842]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.842]                       search = base::search(), system = base::Sys.info())
[17:29:42.842]                   }
[17:29:42.842]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.842]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.842]                     cond$call), session = sessionInformation(), 
[17:29:42.842]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.842]                   signalCondition(cond)
[17:29:42.842]                 }
[17:29:42.842]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.842]                 "immediateCondition"))) {
[17:29:42.842]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.842]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.842]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.842]                   if (TRUE && !signal) {
[17:29:42.842]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.842]                     {
[17:29:42.842]                       inherits <- base::inherits
[17:29:42.842]                       invokeRestart <- base::invokeRestart
[17:29:42.842]                       is.null <- base::is.null
[17:29:42.842]                       muffled <- FALSE
[17:29:42.842]                       if (inherits(cond, "message")) {
[17:29:42.842]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.842]                         if (muffled) 
[17:29:42.842]                           invokeRestart("muffleMessage")
[17:29:42.842]                       }
[17:29:42.842]                       else if (inherits(cond, "warning")) {
[17:29:42.842]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.842]                         if (muffled) 
[17:29:42.842]                           invokeRestart("muffleWarning")
[17:29:42.842]                       }
[17:29:42.842]                       else if (inherits(cond, "condition")) {
[17:29:42.842]                         if (!is.null(pattern)) {
[17:29:42.842]                           computeRestarts <- base::computeRestarts
[17:29:42.842]                           grepl <- base::grepl
[17:29:42.842]                           restarts <- computeRestarts(cond)
[17:29:42.842]                           for (restart in restarts) {
[17:29:42.842]                             name <- restart$name
[17:29:42.842]                             if (is.null(name)) 
[17:29:42.842]                               next
[17:29:42.842]                             if (!grepl(pattern, name)) 
[17:29:42.842]                               next
[17:29:42.842]                             invokeRestart(restart)
[17:29:42.842]                             muffled <- TRUE
[17:29:42.842]                             break
[17:29:42.842]                           }
[17:29:42.842]                         }
[17:29:42.842]                       }
[17:29:42.842]                       invisible(muffled)
[17:29:42.842]                     }
[17:29:42.842]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.842]                   }
[17:29:42.842]                 }
[17:29:42.842]                 else {
[17:29:42.842]                   if (TRUE) {
[17:29:42.842]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.842]                     {
[17:29:42.842]                       inherits <- base::inherits
[17:29:42.842]                       invokeRestart <- base::invokeRestart
[17:29:42.842]                       is.null <- base::is.null
[17:29:42.842]                       muffled <- FALSE
[17:29:42.842]                       if (inherits(cond, "message")) {
[17:29:42.842]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.842]                         if (muffled) 
[17:29:42.842]                           invokeRestart("muffleMessage")
[17:29:42.842]                       }
[17:29:42.842]                       else if (inherits(cond, "warning")) {
[17:29:42.842]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.842]                         if (muffled) 
[17:29:42.842]                           invokeRestart("muffleWarning")
[17:29:42.842]                       }
[17:29:42.842]                       else if (inherits(cond, "condition")) {
[17:29:42.842]                         if (!is.null(pattern)) {
[17:29:42.842]                           computeRestarts <- base::computeRestarts
[17:29:42.842]                           grepl <- base::grepl
[17:29:42.842]                           restarts <- computeRestarts(cond)
[17:29:42.842]                           for (restart in restarts) {
[17:29:42.842]                             name <- restart$name
[17:29:42.842]                             if (is.null(name)) 
[17:29:42.842]                               next
[17:29:42.842]                             if (!grepl(pattern, name)) 
[17:29:42.842]                               next
[17:29:42.842]                             invokeRestart(restart)
[17:29:42.842]                             muffled <- TRUE
[17:29:42.842]                             break
[17:29:42.842]                           }
[17:29:42.842]                         }
[17:29:42.842]                       }
[17:29:42.842]                       invisible(muffled)
[17:29:42.842]                     }
[17:29:42.842]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.842]                   }
[17:29:42.842]                 }
[17:29:42.842]             }
[17:29:42.842]         }))
[17:29:42.842]     }, error = function(ex) {
[17:29:42.842]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.842]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.842]                 ...future.rng), started = ...future.startTime, 
[17:29:42.842]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.842]             version = "1.8"), class = "FutureResult")
[17:29:42.842]     }, finally = {
[17:29:42.842]         if (!identical(...future.workdir, getwd())) 
[17:29:42.842]             setwd(...future.workdir)
[17:29:42.842]         {
[17:29:42.842]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.842]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.842]             }
[17:29:42.842]             base::options(...future.oldOptions)
[17:29:42.842]             if (.Platform$OS.type == "windows") {
[17:29:42.842]                 old_names <- names(...future.oldEnvVars)
[17:29:42.842]                 envs <- base::Sys.getenv()
[17:29:42.842]                 names <- names(envs)
[17:29:42.842]                 common <- intersect(names, old_names)
[17:29:42.842]                 added <- setdiff(names, old_names)
[17:29:42.842]                 removed <- setdiff(old_names, names)
[17:29:42.842]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.842]                   envs[common]]
[17:29:42.842]                 NAMES <- toupper(changed)
[17:29:42.842]                 args <- list()
[17:29:42.842]                 for (kk in seq_along(NAMES)) {
[17:29:42.842]                   name <- changed[[kk]]
[17:29:42.842]                   NAME <- NAMES[[kk]]
[17:29:42.842]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.842]                     next
[17:29:42.842]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.842]                 }
[17:29:42.842]                 NAMES <- toupper(added)
[17:29:42.842]                 for (kk in seq_along(NAMES)) {
[17:29:42.842]                   name <- added[[kk]]
[17:29:42.842]                   NAME <- NAMES[[kk]]
[17:29:42.842]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.842]                     next
[17:29:42.842]                   args[[name]] <- ""
[17:29:42.842]                 }
[17:29:42.842]                 NAMES <- toupper(removed)
[17:29:42.842]                 for (kk in seq_along(NAMES)) {
[17:29:42.842]                   name <- removed[[kk]]
[17:29:42.842]                   NAME <- NAMES[[kk]]
[17:29:42.842]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.842]                     next
[17:29:42.842]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.842]                 }
[17:29:42.842]                 if (length(args) > 0) 
[17:29:42.842]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.842]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.842]             }
[17:29:42.842]             else {
[17:29:42.842]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.842]             }
[17:29:42.842]             {
[17:29:42.842]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.842]                   0L) {
[17:29:42.842]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.842]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.842]                   base::options(opts)
[17:29:42.842]                 }
[17:29:42.842]                 {
[17:29:42.842]                   {
[17:29:42.842]                     base::assign(".Random.seed", c(10407L, 494593694L, 
[17:29:42.842]                     -1181531031L, 730868446L, -1103241363L, -1143349626L, 
[17:29:42.842]                     1175253417L), envir = base::globalenv(), 
[17:29:42.842]                       inherits = FALSE)
[17:29:42.842]                     NULL
[17:29:42.842]                   }
[17:29:42.842]                   options(future.plan = NULL)
[17:29:42.842]                   if (is.na(NA_character_)) 
[17:29:42.842]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.842]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.842]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.842]                     .init = FALSE)
[17:29:42.842]                 }
[17:29:42.842]             }
[17:29:42.842]         }
[17:29:42.842]     })
[17:29:42.842]     if (TRUE) {
[17:29:42.842]         base::sink(type = "output", split = FALSE)
[17:29:42.842]         if (TRUE) {
[17:29:42.842]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.842]         }
[17:29:42.842]         else {
[17:29:42.842]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.842]         }
[17:29:42.842]         base::close(...future.stdout)
[17:29:42.842]         ...future.stdout <- NULL
[17:29:42.842]     }
[17:29:42.842]     ...future.result$conditions <- ...future.conditions
[17:29:42.842]     ...future.result$finished <- base::Sys.time()
[17:29:42.842]     ...future.result
[17:29:42.842] }
[17:29:42.849] assign_globals() ...
[17:29:42.850] List of 1
[17:29:42.850]  $ x: int [1:4] 0 1 2 3
[17:29:42.850]  - attr(*, "where")=List of 1
[17:29:42.850]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.850]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.850]  - attr(*, "resolved")= logi FALSE
[17:29:42.850]  - attr(*, "total_size")= int 133
[17:29:42.850]  - attr(*, "already-done")= logi TRUE
[17:29:42.855] - copied 'x' to environment
[17:29:42.856] assign_globals() ... done
[17:29:42.857] plan(): Setting new future strategy stack:
[17:29:42.857] List of future strategies:
[17:29:42.857] 1. sequential:
[17:29:42.857]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.857]    - tweaked: FALSE
[17:29:42.857]    - call: NULL
[17:29:42.858] plan(): nbrOfWorkers() = 1
[17:29:42.860] plan(): Setting new future strategy stack:
[17:29:42.861] List of future strategies:
[17:29:42.861] 1. sequential:
[17:29:42.861]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.861]    - tweaked: FALSE
[17:29:42.861]    - call: plan(strategy)
[17:29:42.862] plan(): nbrOfWorkers() = 1
[17:29:42.862] SequentialFuture started (and completed)
[17:29:42.863] - Launch lazy future ... done
[17:29:42.863] run() for 'SequentialFuture' ... done
[17:29:42.864] getGlobalsAndPackages() ...
[17:29:42.864] Searching for globals...
[17:29:42.866] - globals found: [3] '{', 'sample', 'x'
[17:29:42.867] Searching for globals ... DONE
[17:29:42.867] Resolving globals: FALSE
[17:29:42.868] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.869] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.869] - globals: [1] 'x'
[17:29:42.870] 
[17:29:42.870] getGlobalsAndPackages() ... DONE
[17:29:42.871] run() for 'Future' ...
[17:29:42.871] - state: 'created'
[17:29:42.871] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.872] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.872] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.873]   - Field: 'label'
[17:29:42.873]   - Field: 'local'
[17:29:42.874]   - Field: 'owner'
[17:29:42.874]   - Field: 'envir'
[17:29:42.874]   - Field: 'packages'
[17:29:42.875]   - Field: 'gc'
[17:29:42.875]   - Field: 'conditions'
[17:29:42.875]   - Field: 'expr'
[17:29:42.876]   - Field: 'uuid'
[17:29:42.876]   - Field: 'seed'
[17:29:42.876]   - Field: 'version'
[17:29:42.877]   - Field: 'result'
[17:29:42.877]   - Field: 'asynchronous'
[17:29:42.877]   - Field: 'calls'
[17:29:42.878]   - Field: 'globals'
[17:29:42.878]   - Field: 'stdout'
[17:29:42.878]   - Field: 'earlySignal'
[17:29:42.879]   - Field: 'lazy'
[17:29:42.879]   - Field: 'state'
[17:29:42.879] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.880] - Launch lazy future ...
[17:29:42.880] Packages needed by the future expression (n = 0): <none>
[17:29:42.881] Packages needed by future strategies (n = 0): <none>
[17:29:42.882] {
[17:29:42.882]     {
[17:29:42.882]         {
[17:29:42.882]             ...future.startTime <- base::Sys.time()
[17:29:42.882]             {
[17:29:42.882]                 {
[17:29:42.882]                   {
[17:29:42.882]                     base::local({
[17:29:42.882]                       has_future <- base::requireNamespace("future", 
[17:29:42.882]                         quietly = TRUE)
[17:29:42.882]                       if (has_future) {
[17:29:42.882]                         ns <- base::getNamespace("future")
[17:29:42.882]                         version <- ns[[".package"]][["version"]]
[17:29:42.882]                         if (is.null(version)) 
[17:29:42.882]                           version <- utils::packageVersion("future")
[17:29:42.882]                       }
[17:29:42.882]                       else {
[17:29:42.882]                         version <- NULL
[17:29:42.882]                       }
[17:29:42.882]                       if (!has_future || version < "1.8.0") {
[17:29:42.882]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.882]                           "", base::R.version$version.string), 
[17:29:42.882]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.882]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.882]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.882]                             "release", "version")], collapse = " "), 
[17:29:42.882]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.882]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.882]                           info)
[17:29:42.882]                         info <- base::paste(info, collapse = "; ")
[17:29:42.882]                         if (!has_future) {
[17:29:42.882]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.882]                             info)
[17:29:42.882]                         }
[17:29:42.882]                         else {
[17:29:42.882]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.882]                             info, version)
[17:29:42.882]                         }
[17:29:42.882]                         base::stop(msg)
[17:29:42.882]                       }
[17:29:42.882]                     })
[17:29:42.882]                   }
[17:29:42.882]                   ...future.strategy.old <- future::plan("list")
[17:29:42.882]                   options(future.plan = NULL)
[17:29:42.882]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.882]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.882]                 }
[17:29:42.882]                 ...future.workdir <- getwd()
[17:29:42.882]             }
[17:29:42.882]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.882]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.882]         }
[17:29:42.882]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.882]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.882]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.882]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.882]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.882]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.882]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.882]             base::names(...future.oldOptions))
[17:29:42.882]     }
[17:29:42.882]     if (FALSE) {
[17:29:42.882]     }
[17:29:42.882]     else {
[17:29:42.882]         if (TRUE) {
[17:29:42.882]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.882]                 open = "w")
[17:29:42.882]         }
[17:29:42.882]         else {
[17:29:42.882]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.882]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.882]         }
[17:29:42.882]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.882]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.882]             base::sink(type = "output", split = FALSE)
[17:29:42.882]             base::close(...future.stdout)
[17:29:42.882]         }, add = TRUE)
[17:29:42.882]     }
[17:29:42.882]     ...future.frame <- base::sys.nframe()
[17:29:42.882]     ...future.conditions <- base::list()
[17:29:42.882]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.882]     if (FALSE) {
[17:29:42.882]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.882]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.882]     }
[17:29:42.882]     ...future.result <- base::tryCatch({
[17:29:42.882]         base::withCallingHandlers({
[17:29:42.882]             ...future.value <- base::withVisible(base::local({
[17:29:42.882]                 sample(x, size = 1L)
[17:29:42.882]             }))
[17:29:42.882]             future::FutureResult(value = ...future.value$value, 
[17:29:42.882]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.882]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.882]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.882]                     ...future.globalenv.names))
[17:29:42.882]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.882]         }, condition = base::local({
[17:29:42.882]             c <- base::c
[17:29:42.882]             inherits <- base::inherits
[17:29:42.882]             invokeRestart <- base::invokeRestart
[17:29:42.882]             length <- base::length
[17:29:42.882]             list <- base::list
[17:29:42.882]             seq.int <- base::seq.int
[17:29:42.882]             signalCondition <- base::signalCondition
[17:29:42.882]             sys.calls <- base::sys.calls
[17:29:42.882]             `[[` <- base::`[[`
[17:29:42.882]             `+` <- base::`+`
[17:29:42.882]             `<<-` <- base::`<<-`
[17:29:42.882]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.882]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.882]                   3L)]
[17:29:42.882]             }
[17:29:42.882]             function(cond) {
[17:29:42.882]                 is_error <- inherits(cond, "error")
[17:29:42.882]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.882]                   NULL)
[17:29:42.882]                 if (is_error) {
[17:29:42.882]                   sessionInformation <- function() {
[17:29:42.882]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.882]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.882]                       search = base::search(), system = base::Sys.info())
[17:29:42.882]                   }
[17:29:42.882]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.882]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.882]                     cond$call), session = sessionInformation(), 
[17:29:42.882]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.882]                   signalCondition(cond)
[17:29:42.882]                 }
[17:29:42.882]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.882]                 "immediateCondition"))) {
[17:29:42.882]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.882]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.882]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.882]                   if (TRUE && !signal) {
[17:29:42.882]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.882]                     {
[17:29:42.882]                       inherits <- base::inherits
[17:29:42.882]                       invokeRestart <- base::invokeRestart
[17:29:42.882]                       is.null <- base::is.null
[17:29:42.882]                       muffled <- FALSE
[17:29:42.882]                       if (inherits(cond, "message")) {
[17:29:42.882]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.882]                         if (muffled) 
[17:29:42.882]                           invokeRestart("muffleMessage")
[17:29:42.882]                       }
[17:29:42.882]                       else if (inherits(cond, "warning")) {
[17:29:42.882]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.882]                         if (muffled) 
[17:29:42.882]                           invokeRestart("muffleWarning")
[17:29:42.882]                       }
[17:29:42.882]                       else if (inherits(cond, "condition")) {
[17:29:42.882]                         if (!is.null(pattern)) {
[17:29:42.882]                           computeRestarts <- base::computeRestarts
[17:29:42.882]                           grepl <- base::grepl
[17:29:42.882]                           restarts <- computeRestarts(cond)
[17:29:42.882]                           for (restart in restarts) {
[17:29:42.882]                             name <- restart$name
[17:29:42.882]                             if (is.null(name)) 
[17:29:42.882]                               next
[17:29:42.882]                             if (!grepl(pattern, name)) 
[17:29:42.882]                               next
[17:29:42.882]                             invokeRestart(restart)
[17:29:42.882]                             muffled <- TRUE
[17:29:42.882]                             break
[17:29:42.882]                           }
[17:29:42.882]                         }
[17:29:42.882]                       }
[17:29:42.882]                       invisible(muffled)
[17:29:42.882]                     }
[17:29:42.882]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.882]                   }
[17:29:42.882]                 }
[17:29:42.882]                 else {
[17:29:42.882]                   if (TRUE) {
[17:29:42.882]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.882]                     {
[17:29:42.882]                       inherits <- base::inherits
[17:29:42.882]                       invokeRestart <- base::invokeRestart
[17:29:42.882]                       is.null <- base::is.null
[17:29:42.882]                       muffled <- FALSE
[17:29:42.882]                       if (inherits(cond, "message")) {
[17:29:42.882]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.882]                         if (muffled) 
[17:29:42.882]                           invokeRestart("muffleMessage")
[17:29:42.882]                       }
[17:29:42.882]                       else if (inherits(cond, "warning")) {
[17:29:42.882]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.882]                         if (muffled) 
[17:29:42.882]                           invokeRestart("muffleWarning")
[17:29:42.882]                       }
[17:29:42.882]                       else if (inherits(cond, "condition")) {
[17:29:42.882]                         if (!is.null(pattern)) {
[17:29:42.882]                           computeRestarts <- base::computeRestarts
[17:29:42.882]                           grepl <- base::grepl
[17:29:42.882]                           restarts <- computeRestarts(cond)
[17:29:42.882]                           for (restart in restarts) {
[17:29:42.882]                             name <- restart$name
[17:29:42.882]                             if (is.null(name)) 
[17:29:42.882]                               next
[17:29:42.882]                             if (!grepl(pattern, name)) 
[17:29:42.882]                               next
[17:29:42.882]                             invokeRestart(restart)
[17:29:42.882]                             muffled <- TRUE
[17:29:42.882]                             break
[17:29:42.882]                           }
[17:29:42.882]                         }
[17:29:42.882]                       }
[17:29:42.882]                       invisible(muffled)
[17:29:42.882]                     }
[17:29:42.882]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.882]                   }
[17:29:42.882]                 }
[17:29:42.882]             }
[17:29:42.882]         }))
[17:29:42.882]     }, error = function(ex) {
[17:29:42.882]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.882]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.882]                 ...future.rng), started = ...future.startTime, 
[17:29:42.882]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.882]             version = "1.8"), class = "FutureResult")
[17:29:42.882]     }, finally = {
[17:29:42.882]         if (!identical(...future.workdir, getwd())) 
[17:29:42.882]             setwd(...future.workdir)
[17:29:42.882]         {
[17:29:42.882]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.882]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.882]             }
[17:29:42.882]             base::options(...future.oldOptions)
[17:29:42.882]             if (.Platform$OS.type == "windows") {
[17:29:42.882]                 old_names <- names(...future.oldEnvVars)
[17:29:42.882]                 envs <- base::Sys.getenv()
[17:29:42.882]                 names <- names(envs)
[17:29:42.882]                 common <- intersect(names, old_names)
[17:29:42.882]                 added <- setdiff(names, old_names)
[17:29:42.882]                 removed <- setdiff(old_names, names)
[17:29:42.882]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.882]                   envs[common]]
[17:29:42.882]                 NAMES <- toupper(changed)
[17:29:42.882]                 args <- list()
[17:29:42.882]                 for (kk in seq_along(NAMES)) {
[17:29:42.882]                   name <- changed[[kk]]
[17:29:42.882]                   NAME <- NAMES[[kk]]
[17:29:42.882]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.882]                     next
[17:29:42.882]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.882]                 }
[17:29:42.882]                 NAMES <- toupper(added)
[17:29:42.882]                 for (kk in seq_along(NAMES)) {
[17:29:42.882]                   name <- added[[kk]]
[17:29:42.882]                   NAME <- NAMES[[kk]]
[17:29:42.882]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.882]                     next
[17:29:42.882]                   args[[name]] <- ""
[17:29:42.882]                 }
[17:29:42.882]                 NAMES <- toupper(removed)
[17:29:42.882]                 for (kk in seq_along(NAMES)) {
[17:29:42.882]                   name <- removed[[kk]]
[17:29:42.882]                   NAME <- NAMES[[kk]]
[17:29:42.882]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.882]                     next
[17:29:42.882]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.882]                 }
[17:29:42.882]                 if (length(args) > 0) 
[17:29:42.882]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.882]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.882]             }
[17:29:42.882]             else {
[17:29:42.882]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.882]             }
[17:29:42.882]             {
[17:29:42.882]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.882]                   0L) {
[17:29:42.882]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.882]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.882]                   base::options(opts)
[17:29:42.882]                 }
[17:29:42.882]                 {
[17:29:42.882]                   {
[17:29:42.882]                     base::assign(".Random.seed", c(10407L, 730868446L, 
[17:29:42.882]                     1126349855L, -1174646151L, 1175253417L, 1985358547L, 
[17:29:42.882]                     -157742270L), envir = base::globalenv(), 
[17:29:42.882]                       inherits = FALSE)
[17:29:42.882]                     NULL
[17:29:42.882]                   }
[17:29:42.882]                   options(future.plan = NULL)
[17:29:42.882]                   if (is.na(NA_character_)) 
[17:29:42.882]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.882]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.882]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.882]                     .init = FALSE)
[17:29:42.882]                 }
[17:29:42.882]             }
[17:29:42.882]         }
[17:29:42.882]     })
[17:29:42.882]     if (TRUE) {
[17:29:42.882]         base::sink(type = "output", split = FALSE)
[17:29:42.882]         if (TRUE) {
[17:29:42.882]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.882]         }
[17:29:42.882]         else {
[17:29:42.882]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.882]         }
[17:29:42.882]         base::close(...future.stdout)
[17:29:42.882]         ...future.stdout <- NULL
[17:29:42.882]     }
[17:29:42.882]     ...future.result$conditions <- ...future.conditions
[17:29:42.882]     ...future.result$finished <- base::Sys.time()
[17:29:42.882]     ...future.result
[17:29:42.882] }
[17:29:42.888] assign_globals() ...
[17:29:42.888] List of 1
[17:29:42.888]  $ x: int [1:4] 0 1 2 3
[17:29:42.888]  - attr(*, "where")=List of 1
[17:29:42.888]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.888]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.888]  - attr(*, "resolved")= logi FALSE
[17:29:42.888]  - attr(*, "total_size")= int 133
[17:29:42.888]  - attr(*, "already-done")= logi TRUE
[17:29:42.894] - copied 'x' to environment
[17:29:42.895] assign_globals() ... done
[17:29:42.895] plan(): Setting new future strategy stack:
[17:29:42.896] List of future strategies:
[17:29:42.896] 1. sequential:
[17:29:42.896]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.896]    - tweaked: FALSE
[17:29:42.896]    - call: NULL
[17:29:42.897] plan(): nbrOfWorkers() = 1
[17:29:42.899] plan(): Setting new future strategy stack:
[17:29:42.899] List of future strategies:
[17:29:42.899] 1. sequential:
[17:29:42.899]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.899]    - tweaked: FALSE
[17:29:42.899]    - call: plan(strategy)
[17:29:42.900] plan(): nbrOfWorkers() = 1
[17:29:42.901] SequentialFuture started (and completed)
[17:29:42.901] - Launch lazy future ... done
[17:29:42.902] run() for 'SequentialFuture' ... done
[17:29:42.903] getGlobalsAndPackages() ...
[17:29:42.903] Searching for globals...
[17:29:42.905] - globals found: [3] '{', 'sample', 'x'
[17:29:42.906] Searching for globals ... DONE
[17:29:42.906] Resolving globals: FALSE
[17:29:42.907] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.908] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.908] - globals: [1] 'x'
[17:29:42.908] 
[17:29:42.909] getGlobalsAndPackages() ... DONE
[17:29:42.909] run() for 'Future' ...
[17:29:42.910] - state: 'created'
[17:29:42.910] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.911] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.911] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.911]   - Field: 'label'
[17:29:42.912]   - Field: 'local'
[17:29:42.912]   - Field: 'owner'
[17:29:42.912]   - Field: 'envir'
[17:29:42.913]   - Field: 'packages'
[17:29:42.913]   - Field: 'gc'
[17:29:42.913]   - Field: 'conditions'
[17:29:42.914]   - Field: 'expr'
[17:29:42.914]   - Field: 'uuid'
[17:29:42.914]   - Field: 'seed'
[17:29:42.915]   - Field: 'version'
[17:29:42.915]   - Field: 'result'
[17:29:42.915]   - Field: 'asynchronous'
[17:29:42.916]   - Field: 'calls'
[17:29:42.916]   - Field: 'globals'
[17:29:42.916]   - Field: 'stdout'
[17:29:42.917]   - Field: 'earlySignal'
[17:29:42.917]   - Field: 'lazy'
[17:29:42.917]   - Field: 'state'
[17:29:42.917] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.918] - Launch lazy future ...
[17:29:42.918] Packages needed by the future expression (n = 0): <none>
[17:29:42.919] Packages needed by future strategies (n = 0): <none>
[17:29:42.920] {
[17:29:42.920]     {
[17:29:42.920]         {
[17:29:42.920]             ...future.startTime <- base::Sys.time()
[17:29:42.920]             {
[17:29:42.920]                 {
[17:29:42.920]                   {
[17:29:42.920]                     base::local({
[17:29:42.920]                       has_future <- base::requireNamespace("future", 
[17:29:42.920]                         quietly = TRUE)
[17:29:42.920]                       if (has_future) {
[17:29:42.920]                         ns <- base::getNamespace("future")
[17:29:42.920]                         version <- ns[[".package"]][["version"]]
[17:29:42.920]                         if (is.null(version)) 
[17:29:42.920]                           version <- utils::packageVersion("future")
[17:29:42.920]                       }
[17:29:42.920]                       else {
[17:29:42.920]                         version <- NULL
[17:29:42.920]                       }
[17:29:42.920]                       if (!has_future || version < "1.8.0") {
[17:29:42.920]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.920]                           "", base::R.version$version.string), 
[17:29:42.920]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.920]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.920]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.920]                             "release", "version")], collapse = " "), 
[17:29:42.920]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.920]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.920]                           info)
[17:29:42.920]                         info <- base::paste(info, collapse = "; ")
[17:29:42.920]                         if (!has_future) {
[17:29:42.920]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.920]                             info)
[17:29:42.920]                         }
[17:29:42.920]                         else {
[17:29:42.920]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.920]                             info, version)
[17:29:42.920]                         }
[17:29:42.920]                         base::stop(msg)
[17:29:42.920]                       }
[17:29:42.920]                     })
[17:29:42.920]                   }
[17:29:42.920]                   ...future.strategy.old <- future::plan("list")
[17:29:42.920]                   options(future.plan = NULL)
[17:29:42.920]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.920]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.920]                 }
[17:29:42.920]                 ...future.workdir <- getwd()
[17:29:42.920]             }
[17:29:42.920]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.920]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.920]         }
[17:29:42.920]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.920]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.920]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.920]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.920]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.920]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.920]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.920]             base::names(...future.oldOptions))
[17:29:42.920]     }
[17:29:42.920]     if (FALSE) {
[17:29:42.920]     }
[17:29:42.920]     else {
[17:29:42.920]         if (TRUE) {
[17:29:42.920]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.920]                 open = "w")
[17:29:42.920]         }
[17:29:42.920]         else {
[17:29:42.920]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.920]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.920]         }
[17:29:42.920]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.920]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.920]             base::sink(type = "output", split = FALSE)
[17:29:42.920]             base::close(...future.stdout)
[17:29:42.920]         }, add = TRUE)
[17:29:42.920]     }
[17:29:42.920]     ...future.frame <- base::sys.nframe()
[17:29:42.920]     ...future.conditions <- base::list()
[17:29:42.920]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.920]     if (FALSE) {
[17:29:42.920]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.920]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.920]     }
[17:29:42.920]     ...future.result <- base::tryCatch({
[17:29:42.920]         base::withCallingHandlers({
[17:29:42.920]             ...future.value <- base::withVisible(base::local({
[17:29:42.920]                 sample(x, size = 1L)
[17:29:42.920]             }))
[17:29:42.920]             future::FutureResult(value = ...future.value$value, 
[17:29:42.920]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.920]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.920]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.920]                     ...future.globalenv.names))
[17:29:42.920]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.920]         }, condition = base::local({
[17:29:42.920]             c <- base::c
[17:29:42.920]             inherits <- base::inherits
[17:29:42.920]             invokeRestart <- base::invokeRestart
[17:29:42.920]             length <- base::length
[17:29:42.920]             list <- base::list
[17:29:42.920]             seq.int <- base::seq.int
[17:29:42.920]             signalCondition <- base::signalCondition
[17:29:42.920]             sys.calls <- base::sys.calls
[17:29:42.920]             `[[` <- base::`[[`
[17:29:42.920]             `+` <- base::`+`
[17:29:42.920]             `<<-` <- base::`<<-`
[17:29:42.920]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.920]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.920]                   3L)]
[17:29:42.920]             }
[17:29:42.920]             function(cond) {
[17:29:42.920]                 is_error <- inherits(cond, "error")
[17:29:42.920]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.920]                   NULL)
[17:29:42.920]                 if (is_error) {
[17:29:42.920]                   sessionInformation <- function() {
[17:29:42.920]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.920]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.920]                       search = base::search(), system = base::Sys.info())
[17:29:42.920]                   }
[17:29:42.920]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.920]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.920]                     cond$call), session = sessionInformation(), 
[17:29:42.920]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.920]                   signalCondition(cond)
[17:29:42.920]                 }
[17:29:42.920]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.920]                 "immediateCondition"))) {
[17:29:42.920]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.920]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.920]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.920]                   if (TRUE && !signal) {
[17:29:42.920]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.920]                     {
[17:29:42.920]                       inherits <- base::inherits
[17:29:42.920]                       invokeRestart <- base::invokeRestart
[17:29:42.920]                       is.null <- base::is.null
[17:29:42.920]                       muffled <- FALSE
[17:29:42.920]                       if (inherits(cond, "message")) {
[17:29:42.920]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.920]                         if (muffled) 
[17:29:42.920]                           invokeRestart("muffleMessage")
[17:29:42.920]                       }
[17:29:42.920]                       else if (inherits(cond, "warning")) {
[17:29:42.920]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.920]                         if (muffled) 
[17:29:42.920]                           invokeRestart("muffleWarning")
[17:29:42.920]                       }
[17:29:42.920]                       else if (inherits(cond, "condition")) {
[17:29:42.920]                         if (!is.null(pattern)) {
[17:29:42.920]                           computeRestarts <- base::computeRestarts
[17:29:42.920]                           grepl <- base::grepl
[17:29:42.920]                           restarts <- computeRestarts(cond)
[17:29:42.920]                           for (restart in restarts) {
[17:29:42.920]                             name <- restart$name
[17:29:42.920]                             if (is.null(name)) 
[17:29:42.920]                               next
[17:29:42.920]                             if (!grepl(pattern, name)) 
[17:29:42.920]                               next
[17:29:42.920]                             invokeRestart(restart)
[17:29:42.920]                             muffled <- TRUE
[17:29:42.920]                             break
[17:29:42.920]                           }
[17:29:42.920]                         }
[17:29:42.920]                       }
[17:29:42.920]                       invisible(muffled)
[17:29:42.920]                     }
[17:29:42.920]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.920]                   }
[17:29:42.920]                 }
[17:29:42.920]                 else {
[17:29:42.920]                   if (TRUE) {
[17:29:42.920]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.920]                     {
[17:29:42.920]                       inherits <- base::inherits
[17:29:42.920]                       invokeRestart <- base::invokeRestart
[17:29:42.920]                       is.null <- base::is.null
[17:29:42.920]                       muffled <- FALSE
[17:29:42.920]                       if (inherits(cond, "message")) {
[17:29:42.920]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.920]                         if (muffled) 
[17:29:42.920]                           invokeRestart("muffleMessage")
[17:29:42.920]                       }
[17:29:42.920]                       else if (inherits(cond, "warning")) {
[17:29:42.920]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.920]                         if (muffled) 
[17:29:42.920]                           invokeRestart("muffleWarning")
[17:29:42.920]                       }
[17:29:42.920]                       else if (inherits(cond, "condition")) {
[17:29:42.920]                         if (!is.null(pattern)) {
[17:29:42.920]                           computeRestarts <- base::computeRestarts
[17:29:42.920]                           grepl <- base::grepl
[17:29:42.920]                           restarts <- computeRestarts(cond)
[17:29:42.920]                           for (restart in restarts) {
[17:29:42.920]                             name <- restart$name
[17:29:42.920]                             if (is.null(name)) 
[17:29:42.920]                               next
[17:29:42.920]                             if (!grepl(pattern, name)) 
[17:29:42.920]                               next
[17:29:42.920]                             invokeRestart(restart)
[17:29:42.920]                             muffled <- TRUE
[17:29:42.920]                             break
[17:29:42.920]                           }
[17:29:42.920]                         }
[17:29:42.920]                       }
[17:29:42.920]                       invisible(muffled)
[17:29:42.920]                     }
[17:29:42.920]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.920]                   }
[17:29:42.920]                 }
[17:29:42.920]             }
[17:29:42.920]         }))
[17:29:42.920]     }, error = function(ex) {
[17:29:42.920]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.920]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.920]                 ...future.rng), started = ...future.startTime, 
[17:29:42.920]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.920]             version = "1.8"), class = "FutureResult")
[17:29:42.920]     }, finally = {
[17:29:42.920]         if (!identical(...future.workdir, getwd())) 
[17:29:42.920]             setwd(...future.workdir)
[17:29:42.920]         {
[17:29:42.920]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.920]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.920]             }
[17:29:42.920]             base::options(...future.oldOptions)
[17:29:42.920]             if (.Platform$OS.type == "windows") {
[17:29:42.920]                 old_names <- names(...future.oldEnvVars)
[17:29:42.920]                 envs <- base::Sys.getenv()
[17:29:42.920]                 names <- names(envs)
[17:29:42.920]                 common <- intersect(names, old_names)
[17:29:42.920]                 added <- setdiff(names, old_names)
[17:29:42.920]                 removed <- setdiff(old_names, names)
[17:29:42.920]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.920]                   envs[common]]
[17:29:42.920]                 NAMES <- toupper(changed)
[17:29:42.920]                 args <- list()
[17:29:42.920]                 for (kk in seq_along(NAMES)) {
[17:29:42.920]                   name <- changed[[kk]]
[17:29:42.920]                   NAME <- NAMES[[kk]]
[17:29:42.920]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.920]                     next
[17:29:42.920]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.920]                 }
[17:29:42.920]                 NAMES <- toupper(added)
[17:29:42.920]                 for (kk in seq_along(NAMES)) {
[17:29:42.920]                   name <- added[[kk]]
[17:29:42.920]                   NAME <- NAMES[[kk]]
[17:29:42.920]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.920]                     next
[17:29:42.920]                   args[[name]] <- ""
[17:29:42.920]                 }
[17:29:42.920]                 NAMES <- toupper(removed)
[17:29:42.920]                 for (kk in seq_along(NAMES)) {
[17:29:42.920]                   name <- removed[[kk]]
[17:29:42.920]                   NAME <- NAMES[[kk]]
[17:29:42.920]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.920]                     next
[17:29:42.920]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.920]                 }
[17:29:42.920]                 if (length(args) > 0) 
[17:29:42.920]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.920]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.920]             }
[17:29:42.920]             else {
[17:29:42.920]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.920]             }
[17:29:42.920]             {
[17:29:42.920]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.920]                   0L) {
[17:29:42.920]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.920]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.920]                   base::options(opts)
[17:29:42.920]                 }
[17:29:42.920]                 {
[17:29:42.920]                   {
[17:29:42.920]                     base::assign(".Random.seed", c(10407L, -1174646151L, 
[17:29:42.920]                     -1274838046L, 1936438221L, -157742270L, -665298496L, 
[17:29:42.920]                     -72351411L), envir = base::globalenv(), inherits = FALSE)
[17:29:42.920]                     NULL
[17:29:42.920]                   }
[17:29:42.920]                   options(future.plan = NULL)
[17:29:42.920]                   if (is.na(NA_character_)) 
[17:29:42.920]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.920]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.920]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.920]                     .init = FALSE)
[17:29:42.920]                 }
[17:29:42.920]             }
[17:29:42.920]         }
[17:29:42.920]     })
[17:29:42.920]     if (TRUE) {
[17:29:42.920]         base::sink(type = "output", split = FALSE)
[17:29:42.920]         if (TRUE) {
[17:29:42.920]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.920]         }
[17:29:42.920]         else {
[17:29:42.920]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.920]         }
[17:29:42.920]         base::close(...future.stdout)
[17:29:42.920]         ...future.stdout <- NULL
[17:29:42.920]     }
[17:29:42.920]     ...future.result$conditions <- ...future.conditions
[17:29:42.920]     ...future.result$finished <- base::Sys.time()
[17:29:42.920]     ...future.result
[17:29:42.920] }
[17:29:42.925] assign_globals() ...
[17:29:42.926] List of 1
[17:29:42.926]  $ x: int [1:4] 0 1 2 3
[17:29:42.926]  - attr(*, "where")=List of 1
[17:29:42.926]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.926]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.926]  - attr(*, "resolved")= logi FALSE
[17:29:42.926]  - attr(*, "total_size")= int 133
[17:29:42.926]  - attr(*, "already-done")= logi TRUE
[17:29:42.931] - copied 'x' to environment
[17:29:42.932] assign_globals() ... done
[17:29:42.932] plan(): Setting new future strategy stack:
[17:29:42.933] List of future strategies:
[17:29:42.933] 1. sequential:
[17:29:42.933]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.933]    - tweaked: FALSE
[17:29:42.933]    - call: NULL
[17:29:42.934] plan(): nbrOfWorkers() = 1
[17:29:42.936] plan(): Setting new future strategy stack:
[17:29:42.936] List of future strategies:
[17:29:42.936] 1. sequential:
[17:29:42.936]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.936]    - tweaked: FALSE
[17:29:42.936]    - call: plan(strategy)
[17:29:42.937] plan(): nbrOfWorkers() = 1
[17:29:42.938] SequentialFuture started (and completed)
[17:29:42.938] - Launch lazy future ... done
[17:29:42.938] run() for 'SequentialFuture' ... done
[17:29:42.940] getGlobalsAndPackages() ...
[17:29:42.940] Searching for globals...
[17:29:42.942] - globals found: [3] '{', 'sample', 'x'
[17:29:42.943] Searching for globals ... DONE
[17:29:42.943] Resolving globals: FALSE
[17:29:42.944] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:42.945] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:42.945] - globals: [1] 'x'
[17:29:42.945] 
[17:29:42.945] getGlobalsAndPackages() ... DONE
[17:29:42.946] run() for 'Future' ...
[17:29:42.946] - state: 'created'
[17:29:42.947] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:29:42.947] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:29:42.948] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:29:42.948]   - Field: 'label'
[17:29:42.949]   - Field: 'local'
[17:29:42.949]   - Field: 'owner'
[17:29:42.949]   - Field: 'envir'
[17:29:42.949]   - Field: 'packages'
[17:29:42.950]   - Field: 'gc'
[17:29:42.950]   - Field: 'conditions'
[17:29:42.950]   - Field: 'expr'
[17:29:42.951]   - Field: 'uuid'
[17:29:42.951]   - Field: 'seed'
[17:29:42.951]   - Field: 'version'
[17:29:42.952]   - Field: 'result'
[17:29:42.952]   - Field: 'asynchronous'
[17:29:42.952]   - Field: 'calls'
[17:29:42.953]   - Field: 'globals'
[17:29:42.953]   - Field: 'stdout'
[17:29:42.953]   - Field: 'earlySignal'
[17:29:42.954]   - Field: 'lazy'
[17:29:42.954]   - Field: 'state'
[17:29:42.954] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:29:42.954] - Launch lazy future ...
[17:29:42.955] Packages needed by the future expression (n = 0): <none>
[17:29:42.955] Packages needed by future strategies (n = 0): <none>
[17:29:42.956] {
[17:29:42.956]     {
[17:29:42.956]         {
[17:29:42.956]             ...future.startTime <- base::Sys.time()
[17:29:42.956]             {
[17:29:42.956]                 {
[17:29:42.956]                   {
[17:29:42.956]                     base::local({
[17:29:42.956]                       has_future <- base::requireNamespace("future", 
[17:29:42.956]                         quietly = TRUE)
[17:29:42.956]                       if (has_future) {
[17:29:42.956]                         ns <- base::getNamespace("future")
[17:29:42.956]                         version <- ns[[".package"]][["version"]]
[17:29:42.956]                         if (is.null(version)) 
[17:29:42.956]                           version <- utils::packageVersion("future")
[17:29:42.956]                       }
[17:29:42.956]                       else {
[17:29:42.956]                         version <- NULL
[17:29:42.956]                       }
[17:29:42.956]                       if (!has_future || version < "1.8.0") {
[17:29:42.956]                         info <- base::c(r_version = base::gsub("R version ", 
[17:29:42.956]                           "", base::R.version$version.string), 
[17:29:42.956]                           platform = base::sprintf("%s (%s-bit)", 
[17:29:42.956]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:42.956]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:42.956]                             "release", "version")], collapse = " "), 
[17:29:42.956]                           hostname = base::Sys.info()[["nodename"]])
[17:29:42.956]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:29:42.956]                           info)
[17:29:42.956]                         info <- base::paste(info, collapse = "; ")
[17:29:42.956]                         if (!has_future) {
[17:29:42.956]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:42.956]                             info)
[17:29:42.956]                         }
[17:29:42.956]                         else {
[17:29:42.956]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:42.956]                             info, version)
[17:29:42.956]                         }
[17:29:42.956]                         base::stop(msg)
[17:29:42.956]                       }
[17:29:42.956]                     })
[17:29:42.956]                   }
[17:29:42.956]                   ...future.strategy.old <- future::plan("list")
[17:29:42.956]                   options(future.plan = NULL)
[17:29:42.956]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.956]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:42.956]                 }
[17:29:42.956]                 ...future.workdir <- getwd()
[17:29:42.956]             }
[17:29:42.956]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:42.956]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:42.956]         }
[17:29:42.956]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:42.956]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:42.956]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:42.956]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:42.956]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:42.956]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:42.956]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:42.956]             base::names(...future.oldOptions))
[17:29:42.956]     }
[17:29:42.956]     if (FALSE) {
[17:29:42.956]     }
[17:29:42.956]     else {
[17:29:42.956]         if (TRUE) {
[17:29:42.956]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:42.956]                 open = "w")
[17:29:42.956]         }
[17:29:42.956]         else {
[17:29:42.956]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:42.956]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:42.956]         }
[17:29:42.956]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:42.956]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:42.956]             base::sink(type = "output", split = FALSE)
[17:29:42.956]             base::close(...future.stdout)
[17:29:42.956]         }, add = TRUE)
[17:29:42.956]     }
[17:29:42.956]     ...future.frame <- base::sys.nframe()
[17:29:42.956]     ...future.conditions <- base::list()
[17:29:42.956]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:42.956]     if (FALSE) {
[17:29:42.956]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:42.956]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:42.956]     }
[17:29:42.956]     ...future.result <- base::tryCatch({
[17:29:42.956]         base::withCallingHandlers({
[17:29:42.956]             ...future.value <- base::withVisible(base::local({
[17:29:42.956]                 sample(x, size = 1L)
[17:29:42.956]             }))
[17:29:42.956]             future::FutureResult(value = ...future.value$value, 
[17:29:42.956]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.956]                   ...future.rng), globalenv = if (FALSE) 
[17:29:42.956]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:42.956]                     ...future.globalenv.names))
[17:29:42.956]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:42.956]         }, condition = base::local({
[17:29:42.956]             c <- base::c
[17:29:42.956]             inherits <- base::inherits
[17:29:42.956]             invokeRestart <- base::invokeRestart
[17:29:42.956]             length <- base::length
[17:29:42.956]             list <- base::list
[17:29:42.956]             seq.int <- base::seq.int
[17:29:42.956]             signalCondition <- base::signalCondition
[17:29:42.956]             sys.calls <- base::sys.calls
[17:29:42.956]             `[[` <- base::`[[`
[17:29:42.956]             `+` <- base::`+`
[17:29:42.956]             `<<-` <- base::`<<-`
[17:29:42.956]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:42.956]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:42.956]                   3L)]
[17:29:42.956]             }
[17:29:42.956]             function(cond) {
[17:29:42.956]                 is_error <- inherits(cond, "error")
[17:29:42.956]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:42.956]                   NULL)
[17:29:42.956]                 if (is_error) {
[17:29:42.956]                   sessionInformation <- function() {
[17:29:42.956]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:42.956]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:42.956]                       search = base::search(), system = base::Sys.info())
[17:29:42.956]                   }
[17:29:42.956]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.956]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:42.956]                     cond$call), session = sessionInformation(), 
[17:29:42.956]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:42.956]                   signalCondition(cond)
[17:29:42.956]                 }
[17:29:42.956]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:42.956]                 "immediateCondition"))) {
[17:29:42.956]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:42.956]                   ...future.conditions[[length(...future.conditions) + 
[17:29:42.956]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:42.956]                   if (TRUE && !signal) {
[17:29:42.956]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.956]                     {
[17:29:42.956]                       inherits <- base::inherits
[17:29:42.956]                       invokeRestart <- base::invokeRestart
[17:29:42.956]                       is.null <- base::is.null
[17:29:42.956]                       muffled <- FALSE
[17:29:42.956]                       if (inherits(cond, "message")) {
[17:29:42.956]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.956]                         if (muffled) 
[17:29:42.956]                           invokeRestart("muffleMessage")
[17:29:42.956]                       }
[17:29:42.956]                       else if (inherits(cond, "warning")) {
[17:29:42.956]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.956]                         if (muffled) 
[17:29:42.956]                           invokeRestart("muffleWarning")
[17:29:42.956]                       }
[17:29:42.956]                       else if (inherits(cond, "condition")) {
[17:29:42.956]                         if (!is.null(pattern)) {
[17:29:42.956]                           computeRestarts <- base::computeRestarts
[17:29:42.956]                           grepl <- base::grepl
[17:29:42.956]                           restarts <- computeRestarts(cond)
[17:29:42.956]                           for (restart in restarts) {
[17:29:42.956]                             name <- restart$name
[17:29:42.956]                             if (is.null(name)) 
[17:29:42.956]                               next
[17:29:42.956]                             if (!grepl(pattern, name)) 
[17:29:42.956]                               next
[17:29:42.956]                             invokeRestart(restart)
[17:29:42.956]                             muffled <- TRUE
[17:29:42.956]                             break
[17:29:42.956]                           }
[17:29:42.956]                         }
[17:29:42.956]                       }
[17:29:42.956]                       invisible(muffled)
[17:29:42.956]                     }
[17:29:42.956]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.956]                   }
[17:29:42.956]                 }
[17:29:42.956]                 else {
[17:29:42.956]                   if (TRUE) {
[17:29:42.956]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:42.956]                     {
[17:29:42.956]                       inherits <- base::inherits
[17:29:42.956]                       invokeRestart <- base::invokeRestart
[17:29:42.956]                       is.null <- base::is.null
[17:29:42.956]                       muffled <- FALSE
[17:29:42.956]                       if (inherits(cond, "message")) {
[17:29:42.956]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:42.956]                         if (muffled) 
[17:29:42.956]                           invokeRestart("muffleMessage")
[17:29:42.956]                       }
[17:29:42.956]                       else if (inherits(cond, "warning")) {
[17:29:42.956]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:42.956]                         if (muffled) 
[17:29:42.956]                           invokeRestart("muffleWarning")
[17:29:42.956]                       }
[17:29:42.956]                       else if (inherits(cond, "condition")) {
[17:29:42.956]                         if (!is.null(pattern)) {
[17:29:42.956]                           computeRestarts <- base::computeRestarts
[17:29:42.956]                           grepl <- base::grepl
[17:29:42.956]                           restarts <- computeRestarts(cond)
[17:29:42.956]                           for (restart in restarts) {
[17:29:42.956]                             name <- restart$name
[17:29:42.956]                             if (is.null(name)) 
[17:29:42.956]                               next
[17:29:42.956]                             if (!grepl(pattern, name)) 
[17:29:42.956]                               next
[17:29:42.956]                             invokeRestart(restart)
[17:29:42.956]                             muffled <- TRUE
[17:29:42.956]                             break
[17:29:42.956]                           }
[17:29:42.956]                         }
[17:29:42.956]                       }
[17:29:42.956]                       invisible(muffled)
[17:29:42.956]                     }
[17:29:42.956]                     muffleCondition(cond, pattern = "^muffle")
[17:29:42.956]                   }
[17:29:42.956]                 }
[17:29:42.956]             }
[17:29:42.956]         }))
[17:29:42.956]     }, error = function(ex) {
[17:29:42.956]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:42.956]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:42.956]                 ...future.rng), started = ...future.startTime, 
[17:29:42.956]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:42.956]             version = "1.8"), class = "FutureResult")
[17:29:42.956]     }, finally = {
[17:29:42.956]         if (!identical(...future.workdir, getwd())) 
[17:29:42.956]             setwd(...future.workdir)
[17:29:42.956]         {
[17:29:42.956]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:42.956]                 ...future.oldOptions$nwarnings <- NULL
[17:29:42.956]             }
[17:29:42.956]             base::options(...future.oldOptions)
[17:29:42.956]             if (.Platform$OS.type == "windows") {
[17:29:42.956]                 old_names <- names(...future.oldEnvVars)
[17:29:42.956]                 envs <- base::Sys.getenv()
[17:29:42.956]                 names <- names(envs)
[17:29:42.956]                 common <- intersect(names, old_names)
[17:29:42.956]                 added <- setdiff(names, old_names)
[17:29:42.956]                 removed <- setdiff(old_names, names)
[17:29:42.956]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:42.956]                   envs[common]]
[17:29:42.956]                 NAMES <- toupper(changed)
[17:29:42.956]                 args <- list()
[17:29:42.956]                 for (kk in seq_along(NAMES)) {
[17:29:42.956]                   name <- changed[[kk]]
[17:29:42.956]                   NAME <- NAMES[[kk]]
[17:29:42.956]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.956]                     next
[17:29:42.956]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.956]                 }
[17:29:42.956]                 NAMES <- toupper(added)
[17:29:42.956]                 for (kk in seq_along(NAMES)) {
[17:29:42.956]                   name <- added[[kk]]
[17:29:42.956]                   NAME <- NAMES[[kk]]
[17:29:42.956]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.956]                     next
[17:29:42.956]                   args[[name]] <- ""
[17:29:42.956]                 }
[17:29:42.956]                 NAMES <- toupper(removed)
[17:29:42.956]                 for (kk in seq_along(NAMES)) {
[17:29:42.956]                   name <- removed[[kk]]
[17:29:42.956]                   NAME <- NAMES[[kk]]
[17:29:42.956]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:42.956]                     next
[17:29:42.956]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:42.956]                 }
[17:29:42.956]                 if (length(args) > 0) 
[17:29:42.956]                   base::do.call(base::Sys.setenv, args = args)
[17:29:42.956]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:42.956]             }
[17:29:42.956]             else {
[17:29:42.956]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:42.956]             }
[17:29:42.956]             {
[17:29:42.956]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:42.956]                   0L) {
[17:29:42.956]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:42.956]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:42.956]                   base::options(opts)
[17:29:42.956]                 }
[17:29:42.956]                 {
[17:29:42.956]                   {
[17:29:42.956]                     base::assign(".Random.seed", c(10407L, 1936438221L, 
[17:29:42.956]                     1829792224L, 2146401322L, -72351411L, -1184524314L, 
[17:29:42.956]                     -1340892671L), envir = base::globalenv(), 
[17:29:42.956]                       inherits = FALSE)
[17:29:42.956]                     NULL
[17:29:42.956]                   }
[17:29:42.956]                   options(future.plan = NULL)
[17:29:42.956]                   if (is.na(NA_character_)) 
[17:29:42.956]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:42.956]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:42.956]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:42.956]                     .init = FALSE)
[17:29:42.956]                 }
[17:29:42.956]             }
[17:29:42.956]         }
[17:29:42.956]     })
[17:29:42.956]     if (TRUE) {
[17:29:42.956]         base::sink(type = "output", split = FALSE)
[17:29:42.956]         if (TRUE) {
[17:29:42.956]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:42.956]         }
[17:29:42.956]         else {
[17:29:42.956]             ...future.result["stdout"] <- base::list(NULL)
[17:29:42.956]         }
[17:29:42.956]         base::close(...future.stdout)
[17:29:42.956]         ...future.stdout <- NULL
[17:29:42.956]     }
[17:29:42.956]     ...future.result$conditions <- ...future.conditions
[17:29:42.956]     ...future.result$finished <- base::Sys.time()
[17:29:42.956]     ...future.result
[17:29:42.956] }
[17:29:42.963] assign_globals() ...
[17:29:42.963] List of 1
[17:29:42.963]  $ x: int [1:4] 0 1 2 3
[17:29:42.963]  - attr(*, "where")=List of 1
[17:29:42.963]   ..$ x:<environment: R_EmptyEnv> 
[17:29:42.963]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:29:42.963]  - attr(*, "resolved")= logi FALSE
[17:29:42.963]  - attr(*, "total_size")= int 133
[17:29:42.963]  - attr(*, "already-done")= logi TRUE
[17:29:42.969] - copied 'x' to environment
[17:29:42.969] assign_globals() ... done
[17:29:42.970] plan(): Setting new future strategy stack:
[17:29:42.970] List of future strategies:
[17:29:42.970] 1. sequential:
[17:29:42.970]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.970]    - tweaked: FALSE
[17:29:42.970]    - call: NULL
[17:29:42.971] plan(): nbrOfWorkers() = 1
[17:29:42.974] plan(): Setting new future strategy stack:
[17:29:42.974] List of future strategies:
[17:29:42.974] 1. sequential:
[17:29:42.974]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:29:42.974]    - tweaked: FALSE
[17:29:42.974]    - call: plan(strategy)
[17:29:42.975] plan(): nbrOfWorkers() = 1
[17:29:42.975] SequentialFuture started (and completed)
[17:29:42.976] - Launch lazy future ... done
[17:29:42.976] run() for 'SequentialFuture' ... done
[[1]]
[1] 0

[[2]]
[1] 3

[[3]]
[1] 2

[[4]]
[1] 2

sequential ... done
Testing with 1 cores ... DONE
Testing with 2 cores ...
multisession ...
[17:29:42.989] plan(): Setting new future strategy stack:
[17:29:42.990] List of future strategies:
[17:29:42.990] 1. multisession:
[17:29:42.990]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:29:42.990]    - tweaked: FALSE
[17:29:42.990]    - call: plan(strategy)
[17:29:42.991] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:29:42.991] multisession:
[17:29:42.991] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:29:42.991] - tweaked: FALSE
[17:29:42.991] - call: plan(strategy)
[17:29:43.000] getGlobalsAndPackages() ...
[17:29:43.000] Not searching for globals
[17:29:43.000] - globals: [0] <none>
[17:29:43.001] getGlobalsAndPackages() ... DONE
[17:29:43.001] [local output] makeClusterPSOCK() ...
[17:29:43.061] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:29:43.069] [local output] Base port: 36881
[17:29:43.069] [local output] Getting setup options for 2 cluster nodes ...
[17:29:43.069] [local output]  - Node #1 of 2 ...
[17:29:43.070] [local output] localMachine=TRUE => revtunnel=FALSE

[17:29:43.073] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpaYdu10/worker.rank=1.parallelly.parent=135064.20f98353e2288.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpaYdu10/worker.rank=1.parallelly.parent=135064.20f98353e2288.pid\")"'
[17:29:43.629] - Possible to infer worker's PID: TRUE
[17:29:43.630] [local output] Rscript port: 36881

[17:29:43.631] [local output]  - Node #2 of 2 ...
[17:29:43.632] [local output] localMachine=TRUE => revtunnel=FALSE

[17:29:43.634] [local output] Rscript port: 36881

[17:29:43.634] [local output] Getting setup options for 2 cluster nodes ... done
[17:29:43.635] [local output]  - Parallel setup requested for some PSOCK nodes
[17:29:43.636] [local output] Setting up PSOCK nodes in parallel
[17:29:43.636] List of 36
[17:29:43.636]  $ worker          : chr "localhost"
[17:29:43.636]   ..- attr(*, "localhost")= logi TRUE
[17:29:43.636]  $ master          : chr "localhost"
[17:29:43.636]  $ port            : int 36881
[17:29:43.636]  $ connectTimeout  : num 120
[17:29:43.636]  $ timeout         : num 120
[17:29:43.636]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:29:43.636]  $ homogeneous     : logi TRUE
[17:29:43.636]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=rng.R:135064:CRANWIN3:CRAN\" -e "| __truncated__
[17:29:43.636]  $ rscript_envs    : NULL
[17:29:43.636]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:29:43.636]  $ rscript_startup : NULL
[17:29:43.636]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[17:29:43.636]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:29:43.636]  $ methods         : logi TRUE
[17:29:43.636]  $ socketOptions   : chr "no-delay"
[17:29:43.636]  $ useXDR          : logi FALSE
[17:29:43.636]  $ outfile         : chr "/dev/null"
[17:29:43.636]  $ renice          : int NA
[17:29:43.636]  $ rshcmd          : NULL
[17:29:43.636]  $ user            : chr(0) 
[17:29:43.636]  $ revtunnel       : logi FALSE
[17:29:43.636]  $ rshlogfile      : NULL
[17:29:43.636]  $ rshopts         : chr(0) 
[17:29:43.636]  $ rank            : int 1
[17:29:43.636]  $ manual          : logi FALSE
[17:29:43.636]  $ dryrun          : logi FALSE
[17:29:43.636]  $ quiet           : logi FALSE
[17:29:43.636]  $ setup_strategy  : chr "parallel"
[17:29:43.636]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:29:43.636]  $ pidfile         : chr "D:/temp/RtmpaYdu10/worker.rank=1.parallelly.parent=135064.20f98353e2288.pid"
[17:29:43.636]  $ rshcmd_label    : NULL
[17:29:43.636]  $ rsh_call        : NULL
[17:29:43.636]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:29:43.636]  $ localMachine    : logi TRUE
[17:29:43.636]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:29:43.636]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:29:43.636]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:29:43.636]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:29:43.636]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:29:43.636]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[17:29:43.636]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[17:29:43.636]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:29:43.636]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:29:43.636]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:29:43.636]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:29:43.636]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:29:43.636]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:29:43.636]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:29:43.636]  $ arguments       :List of 28
[17:29:43.636]   ..$ worker          : chr "localhost"
[17:29:43.636]   ..$ master          : NULL
[17:29:43.636]   ..$ port            : int 36881
[17:29:43.636]   ..$ connectTimeout  : num 120
[17:29:43.636]   ..$ timeout         : num 120
[17:29:43.636]   ..$ rscript         : NULL
[17:29:43.636]   ..$ homogeneous     : NULL
[17:29:43.636]   ..$ rscript_args    : NULL
[17:29:43.636]   ..$ rscript_envs    : NULL
[17:29:43.636]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:29:43.636]   ..$ rscript_startup : NULL
[17:29:43.636]   ..$ rscript_sh      : chr "auto"
[17:29:43.636]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:29:43.636]   ..$ methods         : logi TRUE
[17:29:43.636]   ..$ socketOptions   : chr "no-delay"
[17:29:43.636]   ..$ useXDR          : logi FALSE
[17:29:43.636]   ..$ outfile         : chr "/dev/null"
[17:29:43.636]   ..$ renice          : int NA
[17:29:43.636]   ..$ rshcmd          : NULL
[17:29:43.636]   ..$ user            : NULL
[17:29:43.636]   ..$ revtunnel       : logi NA
[17:29:43.636]   ..$ rshlogfile      : NULL
[17:29:43.636]   ..$ rshopts         : NULL
[17:29:43.636]   ..$ rank            : int 1
[17:29:43.636]   ..$ manual          : logi FALSE
[17:29:43.636]   ..$ dryrun          : logi FALSE
[17:29:43.636]   ..$ quiet           : logi FALSE
[17:29:43.636]   ..$ setup_strategy  : chr "parallel"
[17:29:43.636]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:29:43.670] [local output] System call to launch all workers:
[17:29:43.670] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=rng.R:135064:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpaYdu10/worker.rank=1.parallelly.parent=135064.20f98353e2288.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=36881 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:29:43.670] [local output] Starting PSOCK main server
[17:29:43.681] [local output] Workers launched
[17:29:43.682] [local output] Waiting for workers to connect back
[17:29:43.682]  - [local output] 0 workers out of 2 ready
[17:29:43.945]  - [local output] 0 workers out of 2 ready
[17:29:43.946]  - [local output] 1 workers out of 2 ready
[17:29:43.955]  - [local output] 1 workers out of 2 ready
[17:29:43.955]  - [local output] 2 workers out of 2 ready
[17:29:43.956] [local output] Launching of 2 workers completed
[17:29:43.956] [local output] Number of nodes in cluster: 2
[17:29:43.957] [local output] Collecting session information from 2 workers
[17:29:43.958] [local output]  - Worker #1 of 2
[17:29:43.960] [local output]  - Worker #2 of 2
[17:29:43.961] [local output] makeClusterPSOCK() ... done
[17:29:43.978] Packages needed by the future expression (n = 0): <none>
[17:29:43.978] Packages needed by future strategies (n = 0): <none>
[17:29:43.979] {
[17:29:43.979]     {
[17:29:43.979]         {
[17:29:43.979]             ...future.startTime <- base::Sys.time()
[17:29:43.979]             {
[17:29:43.979]                 {
[17:29:43.979]                   {
[17:29:43.979]                     {
[17:29:43.979]                       base::local({
[17:29:43.979]                         has_future <- base::requireNamespace("future", 
[17:29:43.979]                           quietly = TRUE)
[17:29:43.979]                         if (has_future) {
[17:29:43.979]                           ns <- base::getNamespace("future")
[17:29:43.979]                           version <- ns[[".package"]][["version"]]
[17:29:43.979]                           if (is.null(version)) 
[17:29:43.979]                             version <- utils::packageVersion("future")
[17:29:43.979]                         }
[17:29:43.979]                         else {
[17:29:43.979]                           version <- NULL
[17:29:43.979]                         }
[17:29:43.979]                         if (!has_future || version < "1.8.0") {
[17:29:43.979]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:43.979]                             "", base::R.version$version.string), 
[17:29:43.979]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:43.979]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:43.979]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:43.979]                               "release", "version")], collapse = " "), 
[17:29:43.979]                             hostname = base::Sys.info()[["nodename"]])
[17:29:43.979]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:43.979]                             info)
[17:29:43.979]                           info <- base::paste(info, collapse = "; ")
[17:29:43.979]                           if (!has_future) {
[17:29:43.979]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:43.979]                               info)
[17:29:43.979]                           }
[17:29:43.979]                           else {
[17:29:43.979]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:43.979]                               info, version)
[17:29:43.979]                           }
[17:29:43.979]                           base::stop(msg)
[17:29:43.979]                         }
[17:29:43.979]                       })
[17:29:43.979]                     }
[17:29:43.979]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:43.979]                     base::options(mc.cores = 1L)
[17:29:43.979]                   }
[17:29:43.979]                   ...future.strategy.old <- future::plan("list")
[17:29:43.979]                   options(future.plan = NULL)
[17:29:43.979]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:43.979]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:43.979]                 }
[17:29:43.979]                 ...future.workdir <- getwd()
[17:29:43.979]             }
[17:29:43.979]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:43.979]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:43.979]         }
[17:29:43.979]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:43.979]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:43.979]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:43.979]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:43.979]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:43.979]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:43.979]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:43.979]             base::names(...future.oldOptions))
[17:29:43.979]     }
[17:29:43.979]     if (FALSE) {
[17:29:43.979]     }
[17:29:43.979]     else {
[17:29:43.979]         if (TRUE) {
[17:29:43.979]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:43.979]                 open = "w")
[17:29:43.979]         }
[17:29:43.979]         else {
[17:29:43.979]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:43.979]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:43.979]         }
[17:29:43.979]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:43.979]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:43.979]             base::sink(type = "output", split = FALSE)
[17:29:43.979]             base::close(...future.stdout)
[17:29:43.979]         }, add = TRUE)
[17:29:43.979]     }
[17:29:43.979]     ...future.frame <- base::sys.nframe()
[17:29:43.979]     ...future.conditions <- base::list()
[17:29:43.979]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:43.979]     if (FALSE) {
[17:29:43.979]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:43.979]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:43.979]     }
[17:29:43.979]     ...future.result <- base::tryCatch({
[17:29:43.979]         base::withCallingHandlers({
[17:29:43.979]             ...future.value <- base::withVisible(base::local({
[17:29:43.979]                 ...future.makeSendCondition <- base::local({
[17:29:43.979]                   sendCondition <- NULL
[17:29:43.979]                   function(frame = 1L) {
[17:29:43.979]                     if (is.function(sendCondition)) 
[17:29:43.979]                       return(sendCondition)
[17:29:43.979]                     ns <- getNamespace("parallel")
[17:29:43.979]                     if (exists("sendData", mode = "function", 
[17:29:43.979]                       envir = ns)) {
[17:29:43.979]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:43.979]                         envir = ns)
[17:29:43.979]                       envir <- sys.frame(frame)
[17:29:43.979]                       master <- NULL
[17:29:43.979]                       while (!identical(envir, .GlobalEnv) && 
[17:29:43.979]                         !identical(envir, emptyenv())) {
[17:29:43.979]                         if (exists("master", mode = "list", envir = envir, 
[17:29:43.979]                           inherits = FALSE)) {
[17:29:43.979]                           master <- get("master", mode = "list", 
[17:29:43.979]                             envir = envir, inherits = FALSE)
[17:29:43.979]                           if (inherits(master, c("SOCKnode", 
[17:29:43.979]                             "SOCK0node"))) {
[17:29:43.979]                             sendCondition <<- function(cond) {
[17:29:43.979]                               data <- list(type = "VALUE", value = cond, 
[17:29:43.979]                                 success = TRUE)
[17:29:43.979]                               parallel_sendData(master, data)
[17:29:43.979]                             }
[17:29:43.979]                             return(sendCondition)
[17:29:43.979]                           }
[17:29:43.979]                         }
[17:29:43.979]                         frame <- frame + 1L
[17:29:43.979]                         envir <- sys.frame(frame)
[17:29:43.979]                       }
[17:29:43.979]                     }
[17:29:43.979]                     sendCondition <<- function(cond) NULL
[17:29:43.979]                   }
[17:29:43.979]                 })
[17:29:43.979]                 withCallingHandlers({
[17:29:43.979]                   NA
[17:29:43.979]                 }, immediateCondition = function(cond) {
[17:29:43.979]                   sendCondition <- ...future.makeSendCondition()
[17:29:43.979]                   sendCondition(cond)
[17:29:43.979]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:43.979]                   {
[17:29:43.979]                     inherits <- base::inherits
[17:29:43.979]                     invokeRestart <- base::invokeRestart
[17:29:43.979]                     is.null <- base::is.null
[17:29:43.979]                     muffled <- FALSE
[17:29:43.979]                     if (inherits(cond, "message")) {
[17:29:43.979]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:43.979]                       if (muffled) 
[17:29:43.979]                         invokeRestart("muffleMessage")
[17:29:43.979]                     }
[17:29:43.979]                     else if (inherits(cond, "warning")) {
[17:29:43.979]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:43.979]                       if (muffled) 
[17:29:43.979]                         invokeRestart("muffleWarning")
[17:29:43.979]                     }
[17:29:43.979]                     else if (inherits(cond, "condition")) {
[17:29:43.979]                       if (!is.null(pattern)) {
[17:29:43.979]                         computeRestarts <- base::computeRestarts
[17:29:43.979]                         grepl <- base::grepl
[17:29:43.979]                         restarts <- computeRestarts(cond)
[17:29:43.979]                         for (restart in restarts) {
[17:29:43.979]                           name <- restart$name
[17:29:43.979]                           if (is.null(name)) 
[17:29:43.979]                             next
[17:29:43.979]                           if (!grepl(pattern, name)) 
[17:29:43.979]                             next
[17:29:43.979]                           invokeRestart(restart)
[17:29:43.979]                           muffled <- TRUE
[17:29:43.979]                           break
[17:29:43.979]                         }
[17:29:43.979]                       }
[17:29:43.979]                     }
[17:29:43.979]                     invisible(muffled)
[17:29:43.979]                   }
[17:29:43.979]                   muffleCondition(cond)
[17:29:43.979]                 })
[17:29:43.979]             }))
[17:29:43.979]             future::FutureResult(value = ...future.value$value, 
[17:29:43.979]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:43.979]                   ...future.rng), globalenv = if (FALSE) 
[17:29:43.979]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:43.979]                     ...future.globalenv.names))
[17:29:43.979]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:43.979]         }, condition = base::local({
[17:29:43.979]             c <- base::c
[17:29:43.979]             inherits <- base::inherits
[17:29:43.979]             invokeRestart <- base::invokeRestart
[17:29:43.979]             length <- base::length
[17:29:43.979]             list <- base::list
[17:29:43.979]             seq.int <- base::seq.int
[17:29:43.979]             signalCondition <- base::signalCondition
[17:29:43.979]             sys.calls <- base::sys.calls
[17:29:43.979]             `[[` <- base::`[[`
[17:29:43.979]             `+` <- base::`+`
[17:29:43.979]             `<<-` <- base::`<<-`
[17:29:43.979]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:43.979]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:43.979]                   3L)]
[17:29:43.979]             }
[17:29:43.979]             function(cond) {
[17:29:43.979]                 is_error <- inherits(cond, "error")
[17:29:43.979]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:43.979]                   NULL)
[17:29:43.979]                 if (is_error) {
[17:29:43.979]                   sessionInformation <- function() {
[17:29:43.979]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:43.979]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:43.979]                       search = base::search(), system = base::Sys.info())
[17:29:43.979]                   }
[17:29:43.979]                   ...future.conditions[[length(...future.conditions) + 
[17:29:43.979]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:43.979]                     cond$call), session = sessionInformation(), 
[17:29:43.979]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:43.979]                   signalCondition(cond)
[17:29:43.979]                 }
[17:29:43.979]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:43.979]                 "immediateCondition"))) {
[17:29:43.979]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:43.979]                   ...future.conditions[[length(...future.conditions) + 
[17:29:43.979]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:43.979]                   if (TRUE && !signal) {
[17:29:43.979]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:43.979]                     {
[17:29:43.979]                       inherits <- base::inherits
[17:29:43.979]                       invokeRestart <- base::invokeRestart
[17:29:43.979]                       is.null <- base::is.null
[17:29:43.979]                       muffled <- FALSE
[17:29:43.979]                       if (inherits(cond, "message")) {
[17:29:43.979]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:43.979]                         if (muffled) 
[17:29:43.979]                           invokeRestart("muffleMessage")
[17:29:43.979]                       }
[17:29:43.979]                       else if (inherits(cond, "warning")) {
[17:29:43.979]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:43.979]                         if (muffled) 
[17:29:43.979]                           invokeRestart("muffleWarning")
[17:29:43.979]                       }
[17:29:43.979]                       else if (inherits(cond, "condition")) {
[17:29:43.979]                         if (!is.null(pattern)) {
[17:29:43.979]                           computeRestarts <- base::computeRestarts
[17:29:43.979]                           grepl <- base::grepl
[17:29:43.979]                           restarts <- computeRestarts(cond)
[17:29:43.979]                           for (restart in restarts) {
[17:29:43.979]                             name <- restart$name
[17:29:43.979]                             if (is.null(name)) 
[17:29:43.979]                               next
[17:29:43.979]                             if (!grepl(pattern, name)) 
[17:29:43.979]                               next
[17:29:43.979]                             invokeRestart(restart)
[17:29:43.979]                             muffled <- TRUE
[17:29:43.979]                             break
[17:29:43.979]                           }
[17:29:43.979]                         }
[17:29:43.979]                       }
[17:29:43.979]                       invisible(muffled)
[17:29:43.979]                     }
[17:29:43.979]                     muffleCondition(cond, pattern = "^muffle")
[17:29:43.979]                   }
[17:29:43.979]                 }
[17:29:43.979]                 else {
[17:29:43.979]                   if (TRUE) {
[17:29:43.979]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:43.979]                     {
[17:29:43.979]                       inherits <- base::inherits
[17:29:43.979]                       invokeRestart <- base::invokeRestart
[17:29:43.979]                       is.null <- base::is.null
[17:29:43.979]                       muffled <- FALSE
[17:29:43.979]                       if (inherits(cond, "message")) {
[17:29:43.979]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:43.979]                         if (muffled) 
[17:29:43.979]                           invokeRestart("muffleMessage")
[17:29:43.979]                       }
[17:29:43.979]                       else if (inherits(cond, "warning")) {
[17:29:43.979]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:43.979]                         if (muffled) 
[17:29:43.979]                           invokeRestart("muffleWarning")
[17:29:43.979]                       }
[17:29:43.979]                       else if (inherits(cond, "condition")) {
[17:29:43.979]                         if (!is.null(pattern)) {
[17:29:43.979]                           computeRestarts <- base::computeRestarts
[17:29:43.979]                           grepl <- base::grepl
[17:29:43.979]                           restarts <- computeRestarts(cond)
[17:29:43.979]                           for (restart in restarts) {
[17:29:43.979]                             name <- restart$name
[17:29:43.979]                             if (is.null(name)) 
[17:29:43.979]                               next
[17:29:43.979]                             if (!grepl(pattern, name)) 
[17:29:43.979]                               next
[17:29:43.979]                             invokeRestart(restart)
[17:29:43.979]                             muffled <- TRUE
[17:29:43.979]                             break
[17:29:43.979]                           }
[17:29:43.979]                         }
[17:29:43.979]                       }
[17:29:43.979]                       invisible(muffled)
[17:29:43.979]                     }
[17:29:43.979]                     muffleCondition(cond, pattern = "^muffle")
[17:29:43.979]                   }
[17:29:43.979]                 }
[17:29:43.979]             }
[17:29:43.979]         }))
[17:29:43.979]     }, error = function(ex) {
[17:29:43.979]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:43.979]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:43.979]                 ...future.rng), started = ...future.startTime, 
[17:29:43.979]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:43.979]             version = "1.8"), class = "FutureResult")
[17:29:43.979]     }, finally = {
[17:29:43.979]         if (!identical(...future.workdir, getwd())) 
[17:29:43.979]             setwd(...future.workdir)
[17:29:43.979]         {
[17:29:43.979]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:43.979]                 ...future.oldOptions$nwarnings <- NULL
[17:29:43.979]             }
[17:29:43.979]             base::options(...future.oldOptions)
[17:29:43.979]             if (.Platform$OS.type == "windows") {
[17:29:43.979]                 old_names <- names(...future.oldEnvVars)
[17:29:43.979]                 envs <- base::Sys.getenv()
[17:29:43.979]                 names <- names(envs)
[17:29:43.979]                 common <- intersect(names, old_names)
[17:29:43.979]                 added <- setdiff(names, old_names)
[17:29:43.979]                 removed <- setdiff(old_names, names)
[17:29:43.979]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:43.979]                   envs[common]]
[17:29:43.979]                 NAMES <- toupper(changed)
[17:29:43.979]                 args <- list()
[17:29:43.979]                 for (kk in seq_along(NAMES)) {
[17:29:43.979]                   name <- changed[[kk]]
[17:29:43.979]                   NAME <- NAMES[[kk]]
[17:29:43.979]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:43.979]                     next
[17:29:43.979]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:43.979]                 }
[17:29:43.979]                 NAMES <- toupper(added)
[17:29:43.979]                 for (kk in seq_along(NAMES)) {
[17:29:43.979]                   name <- added[[kk]]
[17:29:43.979]                   NAME <- NAMES[[kk]]
[17:29:43.979]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:43.979]                     next
[17:29:43.979]                   args[[name]] <- ""
[17:29:43.979]                 }
[17:29:43.979]                 NAMES <- toupper(removed)
[17:29:43.979]                 for (kk in seq_along(NAMES)) {
[17:29:43.979]                   name <- removed[[kk]]
[17:29:43.979]                   NAME <- NAMES[[kk]]
[17:29:43.979]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:43.979]                     next
[17:29:43.979]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:43.979]                 }
[17:29:43.979]                 if (length(args) > 0) 
[17:29:43.979]                   base::do.call(base::Sys.setenv, args = args)
[17:29:43.979]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:43.979]             }
[17:29:43.979]             else {
[17:29:43.979]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:43.979]             }
[17:29:43.979]             {
[17:29:43.979]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:43.979]                   0L) {
[17:29:43.979]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:43.979]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:43.979]                   base::options(opts)
[17:29:43.979]                 }
[17:29:43.979]                 {
[17:29:43.979]                   {
[17:29:43.979]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:43.979]                     NULL
[17:29:43.979]                   }
[17:29:43.979]                   options(future.plan = NULL)
[17:29:43.979]                   if (is.na(NA_character_)) 
[17:29:43.979]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:43.979]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:43.979]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:43.979]                     .init = FALSE)
[17:29:43.979]                 }
[17:29:43.979]             }
[17:29:43.979]         }
[17:29:43.979]     })
[17:29:43.979]     if (TRUE) {
[17:29:43.979]         base::sink(type = "output", split = FALSE)
[17:29:43.979]         if (TRUE) {
[17:29:43.979]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:43.979]         }
[17:29:43.979]         else {
[17:29:43.979]             ...future.result["stdout"] <- base::list(NULL)
[17:29:43.979]         }
[17:29:43.979]         base::close(...future.stdout)
[17:29:43.979]         ...future.stdout <- NULL
[17:29:43.979]     }
[17:29:43.979]     ...future.result$conditions <- ...future.conditions
[17:29:43.979]     ...future.result$finished <- base::Sys.time()
[17:29:43.979]     ...future.result
[17:29:43.979] }
[17:29:44.136] MultisessionFuture started
[17:29:44.136] result() for ClusterFuture ...
[17:29:44.137] receiveMessageFromWorker() for ClusterFuture ...
[17:29:44.138] - Validating connection of MultisessionFuture
[17:29:44.211] - received message: FutureResult
[17:29:44.211] - Received FutureResult
[17:29:44.216] - Erased future from FutureRegistry
[17:29:44.217] result() for ClusterFuture ...
[17:29:44.217] - result already collected: FutureResult
[17:29:44.217] result() for ClusterFuture ... done
[17:29:44.218] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:44.218] result() for ClusterFuture ... done
[17:29:44.218] result() for ClusterFuture ...
[17:29:44.219] - result already collected: FutureResult
[17:29:44.219] result() for ClusterFuture ... done
[17:29:44.219] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:29:44.223] plan(): nbrOfWorkers() = 2
[17:29:44.224] getGlobalsAndPackages() ...
[17:29:44.224] Searching for globals...
[17:29:44.226] - globals found: [3] '{', 'sample', 'x'
[17:29:44.227] Searching for globals ... DONE
[17:29:44.227] Resolving globals: FALSE
[17:29:44.228] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:44.228] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:44.229] - globals: [1] 'x'
[17:29:44.229] 
[17:29:44.229] getGlobalsAndPackages() ... DONE
[17:29:44.230] run() for 'Future' ...
[17:29:44.230] - state: 'created'
[17:29:44.231] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:44.250] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:44.251] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:44.251]   - Field: 'node'
[17:29:44.252]   - Field: 'label'
[17:29:44.252]   - Field: 'local'
[17:29:44.252]   - Field: 'owner'
[17:29:44.252]   - Field: 'envir'
[17:29:44.253]   - Field: 'workers'
[17:29:44.253]   - Field: 'packages'
[17:29:44.253]   - Field: 'gc'
[17:29:44.254]   - Field: 'conditions'
[17:29:44.254]   - Field: 'persistent'
[17:29:44.254]   - Field: 'expr'
[17:29:44.255]   - Field: 'uuid'
[17:29:44.255]   - Field: 'seed'
[17:29:44.255]   - Field: 'version'
[17:29:44.256]   - Field: 'result'
[17:29:44.256]   - Field: 'asynchronous'
[17:29:44.256]   - Field: 'calls'
[17:29:44.257]   - Field: 'globals'
[17:29:44.257]   - Field: 'stdout'
[17:29:44.257]   - Field: 'earlySignal'
[17:29:44.258]   - Field: 'lazy'
[17:29:44.258]   - Field: 'state'
[17:29:44.258] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:44.259] - Launch lazy future ...
[17:29:44.259] Packages needed by the future expression (n = 0): <none>
[17:29:44.260] Packages needed by future strategies (n = 0): <none>
[17:29:44.261] {
[17:29:44.261]     {
[17:29:44.261]         {
[17:29:44.261]             ...future.startTime <- base::Sys.time()
[17:29:44.261]             {
[17:29:44.261]                 {
[17:29:44.261]                   {
[17:29:44.261]                     {
[17:29:44.261]                       {
[17:29:44.261]                         base::local({
[17:29:44.261]                           has_future <- base::requireNamespace("future", 
[17:29:44.261]                             quietly = TRUE)
[17:29:44.261]                           if (has_future) {
[17:29:44.261]                             ns <- base::getNamespace("future")
[17:29:44.261]                             version <- ns[[".package"]][["version"]]
[17:29:44.261]                             if (is.null(version)) 
[17:29:44.261]                               version <- utils::packageVersion("future")
[17:29:44.261]                           }
[17:29:44.261]                           else {
[17:29:44.261]                             version <- NULL
[17:29:44.261]                           }
[17:29:44.261]                           if (!has_future || version < "1.8.0") {
[17:29:44.261]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:44.261]                               "", base::R.version$version.string), 
[17:29:44.261]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:44.261]                                 base::R.version$platform, 8 * 
[17:29:44.261]                                   base::.Machine$sizeof.pointer), 
[17:29:44.261]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:44.261]                                 "release", "version")], collapse = " "), 
[17:29:44.261]                               hostname = base::Sys.info()[["nodename"]])
[17:29:44.261]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:44.261]                               info)
[17:29:44.261]                             info <- base::paste(info, collapse = "; ")
[17:29:44.261]                             if (!has_future) {
[17:29:44.261]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:44.261]                                 info)
[17:29:44.261]                             }
[17:29:44.261]                             else {
[17:29:44.261]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:44.261]                                 info, version)
[17:29:44.261]                             }
[17:29:44.261]                             base::stop(msg)
[17:29:44.261]                           }
[17:29:44.261]                         })
[17:29:44.261]                       }
[17:29:44.261]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:44.261]                       base::options(mc.cores = 1L)
[17:29:44.261]                     }
[17:29:44.261]                     ...future.strategy.old <- future::plan("list")
[17:29:44.261]                     options(future.plan = NULL)
[17:29:44.261]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:44.261]                     future::plan("default", .cleanup = FALSE, 
[17:29:44.261]                       .init = FALSE)
[17:29:44.261]                   }
[17:29:44.261]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[17:29:44.261]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[17:29:44.261]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[17:29:44.261]                 }
[17:29:44.261]                 ...future.workdir <- getwd()
[17:29:44.261]             }
[17:29:44.261]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:44.261]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:44.261]         }
[17:29:44.261]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:44.261]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:44.261]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:44.261]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:44.261]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:44.261]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:44.261]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:44.261]             base::names(...future.oldOptions))
[17:29:44.261]     }
[17:29:44.261]     if (FALSE) {
[17:29:44.261]     }
[17:29:44.261]     else {
[17:29:44.261]         if (TRUE) {
[17:29:44.261]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:44.261]                 open = "w")
[17:29:44.261]         }
[17:29:44.261]         else {
[17:29:44.261]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:44.261]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:44.261]         }
[17:29:44.261]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:44.261]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:44.261]             base::sink(type = "output", split = FALSE)
[17:29:44.261]             base::close(...future.stdout)
[17:29:44.261]         }, add = TRUE)
[17:29:44.261]     }
[17:29:44.261]     ...future.frame <- base::sys.nframe()
[17:29:44.261]     ...future.conditions <- base::list()
[17:29:44.261]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:44.261]     if (FALSE) {
[17:29:44.261]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:44.261]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:44.261]     }
[17:29:44.261]     ...future.result <- base::tryCatch({
[17:29:44.261]         base::withCallingHandlers({
[17:29:44.261]             ...future.value <- base::withVisible(base::local({
[17:29:44.261]                 ...future.makeSendCondition <- base::local({
[17:29:44.261]                   sendCondition <- NULL
[17:29:44.261]                   function(frame = 1L) {
[17:29:44.261]                     if (is.function(sendCondition)) 
[17:29:44.261]                       return(sendCondition)
[17:29:44.261]                     ns <- getNamespace("parallel")
[17:29:44.261]                     if (exists("sendData", mode = "function", 
[17:29:44.261]                       envir = ns)) {
[17:29:44.261]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:44.261]                         envir = ns)
[17:29:44.261]                       envir <- sys.frame(frame)
[17:29:44.261]                       master <- NULL
[17:29:44.261]                       while (!identical(envir, .GlobalEnv) && 
[17:29:44.261]                         !identical(envir, emptyenv())) {
[17:29:44.261]                         if (exists("master", mode = "list", envir = envir, 
[17:29:44.261]                           inherits = FALSE)) {
[17:29:44.261]                           master <- get("master", mode = "list", 
[17:29:44.261]                             envir = envir, inherits = FALSE)
[17:29:44.261]                           if (inherits(master, c("SOCKnode", 
[17:29:44.261]                             "SOCK0node"))) {
[17:29:44.261]                             sendCondition <<- function(cond) {
[17:29:44.261]                               data <- list(type = "VALUE", value = cond, 
[17:29:44.261]                                 success = TRUE)
[17:29:44.261]                               parallel_sendData(master, data)
[17:29:44.261]                             }
[17:29:44.261]                             return(sendCondition)
[17:29:44.261]                           }
[17:29:44.261]                         }
[17:29:44.261]                         frame <- frame + 1L
[17:29:44.261]                         envir <- sys.frame(frame)
[17:29:44.261]                       }
[17:29:44.261]                     }
[17:29:44.261]                     sendCondition <<- function(cond) NULL
[17:29:44.261]                   }
[17:29:44.261]                 })
[17:29:44.261]                 withCallingHandlers({
[17:29:44.261]                   {
[17:29:44.261]                     sample(x, size = 1L)
[17:29:44.261]                   }
[17:29:44.261]                 }, immediateCondition = function(cond) {
[17:29:44.261]                   sendCondition <- ...future.makeSendCondition()
[17:29:44.261]                   sendCondition(cond)
[17:29:44.261]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.261]                   {
[17:29:44.261]                     inherits <- base::inherits
[17:29:44.261]                     invokeRestart <- base::invokeRestart
[17:29:44.261]                     is.null <- base::is.null
[17:29:44.261]                     muffled <- FALSE
[17:29:44.261]                     if (inherits(cond, "message")) {
[17:29:44.261]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:44.261]                       if (muffled) 
[17:29:44.261]                         invokeRestart("muffleMessage")
[17:29:44.261]                     }
[17:29:44.261]                     else if (inherits(cond, "warning")) {
[17:29:44.261]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:44.261]                       if (muffled) 
[17:29:44.261]                         invokeRestart("muffleWarning")
[17:29:44.261]                     }
[17:29:44.261]                     else if (inherits(cond, "condition")) {
[17:29:44.261]                       if (!is.null(pattern)) {
[17:29:44.261]                         computeRestarts <- base::computeRestarts
[17:29:44.261]                         grepl <- base::grepl
[17:29:44.261]                         restarts <- computeRestarts(cond)
[17:29:44.261]                         for (restart in restarts) {
[17:29:44.261]                           name <- restart$name
[17:29:44.261]                           if (is.null(name)) 
[17:29:44.261]                             next
[17:29:44.261]                           if (!grepl(pattern, name)) 
[17:29:44.261]                             next
[17:29:44.261]                           invokeRestart(restart)
[17:29:44.261]                           muffled <- TRUE
[17:29:44.261]                           break
[17:29:44.261]                         }
[17:29:44.261]                       }
[17:29:44.261]                     }
[17:29:44.261]                     invisible(muffled)
[17:29:44.261]                   }
[17:29:44.261]                   muffleCondition(cond)
[17:29:44.261]                 })
[17:29:44.261]             }))
[17:29:44.261]             future::FutureResult(value = ...future.value$value, 
[17:29:44.261]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:44.261]                   ...future.rng), globalenv = if (FALSE) 
[17:29:44.261]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:44.261]                     ...future.globalenv.names))
[17:29:44.261]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:44.261]         }, condition = base::local({
[17:29:44.261]             c <- base::c
[17:29:44.261]             inherits <- base::inherits
[17:29:44.261]             invokeRestart <- base::invokeRestart
[17:29:44.261]             length <- base::length
[17:29:44.261]             list <- base::list
[17:29:44.261]             seq.int <- base::seq.int
[17:29:44.261]             signalCondition <- base::signalCondition
[17:29:44.261]             sys.calls <- base::sys.calls
[17:29:44.261]             `[[` <- base::`[[`
[17:29:44.261]             `+` <- base::`+`
[17:29:44.261]             `<<-` <- base::`<<-`
[17:29:44.261]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:44.261]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:44.261]                   3L)]
[17:29:44.261]             }
[17:29:44.261]             function(cond) {
[17:29:44.261]                 is_error <- inherits(cond, "error")
[17:29:44.261]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:44.261]                   NULL)
[17:29:44.261]                 if (is_error) {
[17:29:44.261]                   sessionInformation <- function() {
[17:29:44.261]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:44.261]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:44.261]                       search = base::search(), system = base::Sys.info())
[17:29:44.261]                   }
[17:29:44.261]                   ...future.conditions[[length(...future.conditions) + 
[17:29:44.261]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:44.261]                     cond$call), session = sessionInformation(), 
[17:29:44.261]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:44.261]                   signalCondition(cond)
[17:29:44.261]                 }
[17:29:44.261]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:44.261]                 "immediateCondition"))) {
[17:29:44.261]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:44.261]                   ...future.conditions[[length(...future.conditions) + 
[17:29:44.261]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:44.261]                   if (TRUE && !signal) {
[17:29:44.261]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.261]                     {
[17:29:44.261]                       inherits <- base::inherits
[17:29:44.261]                       invokeRestart <- base::invokeRestart
[17:29:44.261]                       is.null <- base::is.null
[17:29:44.261]                       muffled <- FALSE
[17:29:44.261]                       if (inherits(cond, "message")) {
[17:29:44.261]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:44.261]                         if (muffled) 
[17:29:44.261]                           invokeRestart("muffleMessage")
[17:29:44.261]                       }
[17:29:44.261]                       else if (inherits(cond, "warning")) {
[17:29:44.261]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:44.261]                         if (muffled) 
[17:29:44.261]                           invokeRestart("muffleWarning")
[17:29:44.261]                       }
[17:29:44.261]                       else if (inherits(cond, "condition")) {
[17:29:44.261]                         if (!is.null(pattern)) {
[17:29:44.261]                           computeRestarts <- base::computeRestarts
[17:29:44.261]                           grepl <- base::grepl
[17:29:44.261]                           restarts <- computeRestarts(cond)
[17:29:44.261]                           for (restart in restarts) {
[17:29:44.261]                             name <- restart$name
[17:29:44.261]                             if (is.null(name)) 
[17:29:44.261]                               next
[17:29:44.261]                             if (!grepl(pattern, name)) 
[17:29:44.261]                               next
[17:29:44.261]                             invokeRestart(restart)
[17:29:44.261]                             muffled <- TRUE
[17:29:44.261]                             break
[17:29:44.261]                           }
[17:29:44.261]                         }
[17:29:44.261]                       }
[17:29:44.261]                       invisible(muffled)
[17:29:44.261]                     }
[17:29:44.261]                     muffleCondition(cond, pattern = "^muffle")
[17:29:44.261]                   }
[17:29:44.261]                 }
[17:29:44.261]                 else {
[17:29:44.261]                   if (TRUE) {
[17:29:44.261]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.261]                     {
[17:29:44.261]                       inherits <- base::inherits
[17:29:44.261]                       invokeRestart <- base::invokeRestart
[17:29:44.261]                       is.null <- base::is.null
[17:29:44.261]                       muffled <- FALSE
[17:29:44.261]                       if (inherits(cond, "message")) {
[17:29:44.261]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:44.261]                         if (muffled) 
[17:29:44.261]                           invokeRestart("muffleMessage")
[17:29:44.261]                       }
[17:29:44.261]                       else if (inherits(cond, "warning")) {
[17:29:44.261]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:44.261]                         if (muffled) 
[17:29:44.261]                           invokeRestart("muffleWarning")
[17:29:44.261]                       }
[17:29:44.261]                       else if (inherits(cond, "condition")) {
[17:29:44.261]                         if (!is.null(pattern)) {
[17:29:44.261]                           computeRestarts <- base::computeRestarts
[17:29:44.261]                           grepl <- base::grepl
[17:29:44.261]                           restarts <- computeRestarts(cond)
[17:29:44.261]                           for (restart in restarts) {
[17:29:44.261]                             name <- restart$name
[17:29:44.261]                             if (is.null(name)) 
[17:29:44.261]                               next
[17:29:44.261]                             if (!grepl(pattern, name)) 
[17:29:44.261]                               next
[17:29:44.261]                             invokeRestart(restart)
[17:29:44.261]                             muffled <- TRUE
[17:29:44.261]                             break
[17:29:44.261]                           }
[17:29:44.261]                         }
[17:29:44.261]                       }
[17:29:44.261]                       invisible(muffled)
[17:29:44.261]                     }
[17:29:44.261]                     muffleCondition(cond, pattern = "^muffle")
[17:29:44.261]                   }
[17:29:44.261]                 }
[17:29:44.261]             }
[17:29:44.261]         }))
[17:29:44.261]     }, error = function(ex) {
[17:29:44.261]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:44.261]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:44.261]                 ...future.rng), started = ...future.startTime, 
[17:29:44.261]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:44.261]             version = "1.8"), class = "FutureResult")
[17:29:44.261]     }, finally = {
[17:29:44.261]         if (!identical(...future.workdir, getwd())) 
[17:29:44.261]             setwd(...future.workdir)
[17:29:44.261]         {
[17:29:44.261]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:44.261]                 ...future.oldOptions$nwarnings <- NULL
[17:29:44.261]             }
[17:29:44.261]             base::options(...future.oldOptions)
[17:29:44.261]             if (.Platform$OS.type == "windows") {
[17:29:44.261]                 old_names <- names(...future.oldEnvVars)
[17:29:44.261]                 envs <- base::Sys.getenv()
[17:29:44.261]                 names <- names(envs)
[17:29:44.261]                 common <- intersect(names, old_names)
[17:29:44.261]                 added <- setdiff(names, old_names)
[17:29:44.261]                 removed <- setdiff(old_names, names)
[17:29:44.261]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:44.261]                   envs[common]]
[17:29:44.261]                 NAMES <- toupper(changed)
[17:29:44.261]                 args <- list()
[17:29:44.261]                 for (kk in seq_along(NAMES)) {
[17:29:44.261]                   name <- changed[[kk]]
[17:29:44.261]                   NAME <- NAMES[[kk]]
[17:29:44.261]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.261]                     next
[17:29:44.261]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:44.261]                 }
[17:29:44.261]                 NAMES <- toupper(added)
[17:29:44.261]                 for (kk in seq_along(NAMES)) {
[17:29:44.261]                   name <- added[[kk]]
[17:29:44.261]                   NAME <- NAMES[[kk]]
[17:29:44.261]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.261]                     next
[17:29:44.261]                   args[[name]] <- ""
[17:29:44.261]                 }
[17:29:44.261]                 NAMES <- toupper(removed)
[17:29:44.261]                 for (kk in seq_along(NAMES)) {
[17:29:44.261]                   name <- removed[[kk]]
[17:29:44.261]                   NAME <- NAMES[[kk]]
[17:29:44.261]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.261]                     next
[17:29:44.261]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:44.261]                 }
[17:29:44.261]                 if (length(args) > 0) 
[17:29:44.261]                   base::do.call(base::Sys.setenv, args = args)
[17:29:44.261]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:44.261]             }
[17:29:44.261]             else {
[17:29:44.261]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:44.261]             }
[17:29:44.261]             {
[17:29:44.261]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:44.261]                   0L) {
[17:29:44.261]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:44.261]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:44.261]                   base::options(opts)
[17:29:44.261]                 }
[17:29:44.261]                 {
[17:29:44.261]                   {
[17:29:44.261]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:44.261]                     NULL
[17:29:44.261]                   }
[17:29:44.261]                   options(future.plan = NULL)
[17:29:44.261]                   if (is.na(NA_character_)) 
[17:29:44.261]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:44.261]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:44.261]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:44.261]                     .init = FALSE)
[17:29:44.261]                 }
[17:29:44.261]             }
[17:29:44.261]         }
[17:29:44.261]     })
[17:29:44.261]     if (TRUE) {
[17:29:44.261]         base::sink(type = "output", split = FALSE)
[17:29:44.261]         if (TRUE) {
[17:29:44.261]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:44.261]         }
[17:29:44.261]         else {
[17:29:44.261]             ...future.result["stdout"] <- base::list(NULL)
[17:29:44.261]         }
[17:29:44.261]         base::close(...future.stdout)
[17:29:44.261]         ...future.stdout <- NULL
[17:29:44.261]     }
[17:29:44.261]     ...future.result$conditions <- ...future.conditions
[17:29:44.261]     ...future.result$finished <- base::Sys.time()
[17:29:44.261]     ...future.result
[17:29:44.261] }
[17:29:44.270] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:44.271] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:44.271] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:44.272] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:44.273] MultisessionFuture started
[17:29:44.273] - Launch lazy future ... done
[17:29:44.273] run() for 'MultisessionFuture' ... done
[17:29:44.274] getGlobalsAndPackages() ...
[17:29:44.274] Searching for globals...
[17:29:44.276] - globals found: [3] '{', 'sample', 'x'
[17:29:44.277] Searching for globals ... DONE
[17:29:44.277] Resolving globals: FALSE
[17:29:44.278] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:44.279] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:44.279] - globals: [1] 'x'
[17:29:44.279] 
[17:29:44.279] getGlobalsAndPackages() ... DONE
[17:29:44.280] run() for 'Future' ...
[17:29:44.280] - state: 'created'
[17:29:44.281] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:44.302] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:44.302] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:44.303]   - Field: 'node'
[17:29:44.303]   - Field: 'label'
[17:29:44.303]   - Field: 'local'
[17:29:44.304]   - Field: 'owner'
[17:29:44.304]   - Field: 'envir'
[17:29:44.304]   - Field: 'workers'
[17:29:44.305]   - Field: 'packages'
[17:29:44.305]   - Field: 'gc'
[17:29:44.305]   - Field: 'conditions'
[17:29:44.306]   - Field: 'persistent'
[17:29:44.306]   - Field: 'expr'
[17:29:44.306]   - Field: 'uuid'
[17:29:44.307]   - Field: 'seed'
[17:29:44.307]   - Field: 'version'
[17:29:44.307]   - Field: 'result'
[17:29:44.308]   - Field: 'asynchronous'
[17:29:44.308]   - Field: 'calls'
[17:29:44.308]   - Field: 'globals'
[17:29:44.309]   - Field: 'stdout'
[17:29:44.309]   - Field: 'earlySignal'
[17:29:44.309]   - Field: 'lazy'
[17:29:44.310]   - Field: 'state'
[17:29:44.310] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:44.310] - Launch lazy future ...
[17:29:44.311] Packages needed by the future expression (n = 0): <none>
[17:29:44.311] Packages needed by future strategies (n = 0): <none>
[17:29:44.312] {
[17:29:44.312]     {
[17:29:44.312]         {
[17:29:44.312]             ...future.startTime <- base::Sys.time()
[17:29:44.312]             {
[17:29:44.312]                 {
[17:29:44.312]                   {
[17:29:44.312]                     {
[17:29:44.312]                       {
[17:29:44.312]                         base::local({
[17:29:44.312]                           has_future <- base::requireNamespace("future", 
[17:29:44.312]                             quietly = TRUE)
[17:29:44.312]                           if (has_future) {
[17:29:44.312]                             ns <- base::getNamespace("future")
[17:29:44.312]                             version <- ns[[".package"]][["version"]]
[17:29:44.312]                             if (is.null(version)) 
[17:29:44.312]                               version <- utils::packageVersion("future")
[17:29:44.312]                           }
[17:29:44.312]                           else {
[17:29:44.312]                             version <- NULL
[17:29:44.312]                           }
[17:29:44.312]                           if (!has_future || version < "1.8.0") {
[17:29:44.312]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:44.312]                               "", base::R.version$version.string), 
[17:29:44.312]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:44.312]                                 base::R.version$platform, 8 * 
[17:29:44.312]                                   base::.Machine$sizeof.pointer), 
[17:29:44.312]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:44.312]                                 "release", "version")], collapse = " "), 
[17:29:44.312]                               hostname = base::Sys.info()[["nodename"]])
[17:29:44.312]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:44.312]                               info)
[17:29:44.312]                             info <- base::paste(info, collapse = "; ")
[17:29:44.312]                             if (!has_future) {
[17:29:44.312]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:44.312]                                 info)
[17:29:44.312]                             }
[17:29:44.312]                             else {
[17:29:44.312]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:44.312]                                 info, version)
[17:29:44.312]                             }
[17:29:44.312]                             base::stop(msg)
[17:29:44.312]                           }
[17:29:44.312]                         })
[17:29:44.312]                       }
[17:29:44.312]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:44.312]                       base::options(mc.cores = 1L)
[17:29:44.312]                     }
[17:29:44.312]                     ...future.strategy.old <- future::plan("list")
[17:29:44.312]                     options(future.plan = NULL)
[17:29:44.312]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:44.312]                     future::plan("default", .cleanup = FALSE, 
[17:29:44.312]                       .init = FALSE)
[17:29:44.312]                   }
[17:29:44.312]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[17:29:44.312]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[17:29:44.312]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[17:29:44.312]                 }
[17:29:44.312]                 ...future.workdir <- getwd()
[17:29:44.312]             }
[17:29:44.312]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:44.312]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:44.312]         }
[17:29:44.312]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:44.312]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:44.312]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:44.312]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:44.312]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:44.312]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:44.312]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:44.312]             base::names(...future.oldOptions))
[17:29:44.312]     }
[17:29:44.312]     if (FALSE) {
[17:29:44.312]     }
[17:29:44.312]     else {
[17:29:44.312]         if (TRUE) {
[17:29:44.312]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:44.312]                 open = "w")
[17:29:44.312]         }
[17:29:44.312]         else {
[17:29:44.312]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:44.312]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:44.312]         }
[17:29:44.312]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:44.312]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:44.312]             base::sink(type = "output", split = FALSE)
[17:29:44.312]             base::close(...future.stdout)
[17:29:44.312]         }, add = TRUE)
[17:29:44.312]     }
[17:29:44.312]     ...future.frame <- base::sys.nframe()
[17:29:44.312]     ...future.conditions <- base::list()
[17:29:44.312]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:44.312]     if (FALSE) {
[17:29:44.312]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:44.312]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:44.312]     }
[17:29:44.312]     ...future.result <- base::tryCatch({
[17:29:44.312]         base::withCallingHandlers({
[17:29:44.312]             ...future.value <- base::withVisible(base::local({
[17:29:44.312]                 ...future.makeSendCondition <- base::local({
[17:29:44.312]                   sendCondition <- NULL
[17:29:44.312]                   function(frame = 1L) {
[17:29:44.312]                     if (is.function(sendCondition)) 
[17:29:44.312]                       return(sendCondition)
[17:29:44.312]                     ns <- getNamespace("parallel")
[17:29:44.312]                     if (exists("sendData", mode = "function", 
[17:29:44.312]                       envir = ns)) {
[17:29:44.312]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:44.312]                         envir = ns)
[17:29:44.312]                       envir <- sys.frame(frame)
[17:29:44.312]                       master <- NULL
[17:29:44.312]                       while (!identical(envir, .GlobalEnv) && 
[17:29:44.312]                         !identical(envir, emptyenv())) {
[17:29:44.312]                         if (exists("master", mode = "list", envir = envir, 
[17:29:44.312]                           inherits = FALSE)) {
[17:29:44.312]                           master <- get("master", mode = "list", 
[17:29:44.312]                             envir = envir, inherits = FALSE)
[17:29:44.312]                           if (inherits(master, c("SOCKnode", 
[17:29:44.312]                             "SOCK0node"))) {
[17:29:44.312]                             sendCondition <<- function(cond) {
[17:29:44.312]                               data <- list(type = "VALUE", value = cond, 
[17:29:44.312]                                 success = TRUE)
[17:29:44.312]                               parallel_sendData(master, data)
[17:29:44.312]                             }
[17:29:44.312]                             return(sendCondition)
[17:29:44.312]                           }
[17:29:44.312]                         }
[17:29:44.312]                         frame <- frame + 1L
[17:29:44.312]                         envir <- sys.frame(frame)
[17:29:44.312]                       }
[17:29:44.312]                     }
[17:29:44.312]                     sendCondition <<- function(cond) NULL
[17:29:44.312]                   }
[17:29:44.312]                 })
[17:29:44.312]                 withCallingHandlers({
[17:29:44.312]                   {
[17:29:44.312]                     sample(x, size = 1L)
[17:29:44.312]                   }
[17:29:44.312]                 }, immediateCondition = function(cond) {
[17:29:44.312]                   sendCondition <- ...future.makeSendCondition()
[17:29:44.312]                   sendCondition(cond)
[17:29:44.312]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.312]                   {
[17:29:44.312]                     inherits <- base::inherits
[17:29:44.312]                     invokeRestart <- base::invokeRestart
[17:29:44.312]                     is.null <- base::is.null
[17:29:44.312]                     muffled <- FALSE
[17:29:44.312]                     if (inherits(cond, "message")) {
[17:29:44.312]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:44.312]                       if (muffled) 
[17:29:44.312]                         invokeRestart("muffleMessage")
[17:29:44.312]                     }
[17:29:44.312]                     else if (inherits(cond, "warning")) {
[17:29:44.312]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:44.312]                       if (muffled) 
[17:29:44.312]                         invokeRestart("muffleWarning")
[17:29:44.312]                     }
[17:29:44.312]                     else if (inherits(cond, "condition")) {
[17:29:44.312]                       if (!is.null(pattern)) {
[17:29:44.312]                         computeRestarts <- base::computeRestarts
[17:29:44.312]                         grepl <- base::grepl
[17:29:44.312]                         restarts <- computeRestarts(cond)
[17:29:44.312]                         for (restart in restarts) {
[17:29:44.312]                           name <- restart$name
[17:29:44.312]                           if (is.null(name)) 
[17:29:44.312]                             next
[17:29:44.312]                           if (!grepl(pattern, name)) 
[17:29:44.312]                             next
[17:29:44.312]                           invokeRestart(restart)
[17:29:44.312]                           muffled <- TRUE
[17:29:44.312]                           break
[17:29:44.312]                         }
[17:29:44.312]                       }
[17:29:44.312]                     }
[17:29:44.312]                     invisible(muffled)
[17:29:44.312]                   }
[17:29:44.312]                   muffleCondition(cond)
[17:29:44.312]                 })
[17:29:44.312]             }))
[17:29:44.312]             future::FutureResult(value = ...future.value$value, 
[17:29:44.312]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:44.312]                   ...future.rng), globalenv = if (FALSE) 
[17:29:44.312]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:44.312]                     ...future.globalenv.names))
[17:29:44.312]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:44.312]         }, condition = base::local({
[17:29:44.312]             c <- base::c
[17:29:44.312]             inherits <- base::inherits
[17:29:44.312]             invokeRestart <- base::invokeRestart
[17:29:44.312]             length <- base::length
[17:29:44.312]             list <- base::list
[17:29:44.312]             seq.int <- base::seq.int
[17:29:44.312]             signalCondition <- base::signalCondition
[17:29:44.312]             sys.calls <- base::sys.calls
[17:29:44.312]             `[[` <- base::`[[`
[17:29:44.312]             `+` <- base::`+`
[17:29:44.312]             `<<-` <- base::`<<-`
[17:29:44.312]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:44.312]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:44.312]                   3L)]
[17:29:44.312]             }
[17:29:44.312]             function(cond) {
[17:29:44.312]                 is_error <- inherits(cond, "error")
[17:29:44.312]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:44.312]                   NULL)
[17:29:44.312]                 if (is_error) {
[17:29:44.312]                   sessionInformation <- function() {
[17:29:44.312]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:44.312]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:44.312]                       search = base::search(), system = base::Sys.info())
[17:29:44.312]                   }
[17:29:44.312]                   ...future.conditions[[length(...future.conditions) + 
[17:29:44.312]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:44.312]                     cond$call), session = sessionInformation(), 
[17:29:44.312]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:44.312]                   signalCondition(cond)
[17:29:44.312]                 }
[17:29:44.312]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:44.312]                 "immediateCondition"))) {
[17:29:44.312]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:44.312]                   ...future.conditions[[length(...future.conditions) + 
[17:29:44.312]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:44.312]                   if (TRUE && !signal) {
[17:29:44.312]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.312]                     {
[17:29:44.312]                       inherits <- base::inherits
[17:29:44.312]                       invokeRestart <- base::invokeRestart
[17:29:44.312]                       is.null <- base::is.null
[17:29:44.312]                       muffled <- FALSE
[17:29:44.312]                       if (inherits(cond, "message")) {
[17:29:44.312]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:44.312]                         if (muffled) 
[17:29:44.312]                           invokeRestart("muffleMessage")
[17:29:44.312]                       }
[17:29:44.312]                       else if (inherits(cond, "warning")) {
[17:29:44.312]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:44.312]                         if (muffled) 
[17:29:44.312]                           invokeRestart("muffleWarning")
[17:29:44.312]                       }
[17:29:44.312]                       else if (inherits(cond, "condition")) {
[17:29:44.312]                         if (!is.null(pattern)) {
[17:29:44.312]                           computeRestarts <- base::computeRestarts
[17:29:44.312]                           grepl <- base::grepl
[17:29:44.312]                           restarts <- computeRestarts(cond)
[17:29:44.312]                           for (restart in restarts) {
[17:29:44.312]                             name <- restart$name
[17:29:44.312]                             if (is.null(name)) 
[17:29:44.312]                               next
[17:29:44.312]                             if (!grepl(pattern, name)) 
[17:29:44.312]                               next
[17:29:44.312]                             invokeRestart(restart)
[17:29:44.312]                             muffled <- TRUE
[17:29:44.312]                             break
[17:29:44.312]                           }
[17:29:44.312]                         }
[17:29:44.312]                       }
[17:29:44.312]                       invisible(muffled)
[17:29:44.312]                     }
[17:29:44.312]                     muffleCondition(cond, pattern = "^muffle")
[17:29:44.312]                   }
[17:29:44.312]                 }
[17:29:44.312]                 else {
[17:29:44.312]                   if (TRUE) {
[17:29:44.312]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.312]                     {
[17:29:44.312]                       inherits <- base::inherits
[17:29:44.312]                       invokeRestart <- base::invokeRestart
[17:29:44.312]                       is.null <- base::is.null
[17:29:44.312]                       muffled <- FALSE
[17:29:44.312]                       if (inherits(cond, "message")) {
[17:29:44.312]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:44.312]                         if (muffled) 
[17:29:44.312]                           invokeRestart("muffleMessage")
[17:29:44.312]                       }
[17:29:44.312]                       else if (inherits(cond, "warning")) {
[17:29:44.312]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:44.312]                         if (muffled) 
[17:29:44.312]                           invokeRestart("muffleWarning")
[17:29:44.312]                       }
[17:29:44.312]                       else if (inherits(cond, "condition")) {
[17:29:44.312]                         if (!is.null(pattern)) {
[17:29:44.312]                           computeRestarts <- base::computeRestarts
[17:29:44.312]                           grepl <- base::grepl
[17:29:44.312]                           restarts <- computeRestarts(cond)
[17:29:44.312]                           for (restart in restarts) {
[17:29:44.312]                             name <- restart$name
[17:29:44.312]                             if (is.null(name)) 
[17:29:44.312]                               next
[17:29:44.312]                             if (!grepl(pattern, name)) 
[17:29:44.312]                               next
[17:29:44.312]                             invokeRestart(restart)
[17:29:44.312]                             muffled <- TRUE
[17:29:44.312]                             break
[17:29:44.312]                           }
[17:29:44.312]                         }
[17:29:44.312]                       }
[17:29:44.312]                       invisible(muffled)
[17:29:44.312]                     }
[17:29:44.312]                     muffleCondition(cond, pattern = "^muffle")
[17:29:44.312]                   }
[17:29:44.312]                 }
[17:29:44.312]             }
[17:29:44.312]         }))
[17:29:44.312]     }, error = function(ex) {
[17:29:44.312]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:44.312]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:44.312]                 ...future.rng), started = ...future.startTime, 
[17:29:44.312]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:44.312]             version = "1.8"), class = "FutureResult")
[17:29:44.312]     }, finally = {
[17:29:44.312]         if (!identical(...future.workdir, getwd())) 
[17:29:44.312]             setwd(...future.workdir)
[17:29:44.312]         {
[17:29:44.312]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:44.312]                 ...future.oldOptions$nwarnings <- NULL
[17:29:44.312]             }
[17:29:44.312]             base::options(...future.oldOptions)
[17:29:44.312]             if (.Platform$OS.type == "windows") {
[17:29:44.312]                 old_names <- names(...future.oldEnvVars)
[17:29:44.312]                 envs <- base::Sys.getenv()
[17:29:44.312]                 names <- names(envs)
[17:29:44.312]                 common <- intersect(names, old_names)
[17:29:44.312]                 added <- setdiff(names, old_names)
[17:29:44.312]                 removed <- setdiff(old_names, names)
[17:29:44.312]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:44.312]                   envs[common]]
[17:29:44.312]                 NAMES <- toupper(changed)
[17:29:44.312]                 args <- list()
[17:29:44.312]                 for (kk in seq_along(NAMES)) {
[17:29:44.312]                   name <- changed[[kk]]
[17:29:44.312]                   NAME <- NAMES[[kk]]
[17:29:44.312]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.312]                     next
[17:29:44.312]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:44.312]                 }
[17:29:44.312]                 NAMES <- toupper(added)
[17:29:44.312]                 for (kk in seq_along(NAMES)) {
[17:29:44.312]                   name <- added[[kk]]
[17:29:44.312]                   NAME <- NAMES[[kk]]
[17:29:44.312]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.312]                     next
[17:29:44.312]                   args[[name]] <- ""
[17:29:44.312]                 }
[17:29:44.312]                 NAMES <- toupper(removed)
[17:29:44.312]                 for (kk in seq_along(NAMES)) {
[17:29:44.312]                   name <- removed[[kk]]
[17:29:44.312]                   NAME <- NAMES[[kk]]
[17:29:44.312]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.312]                     next
[17:29:44.312]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:44.312]                 }
[17:29:44.312]                 if (length(args) > 0) 
[17:29:44.312]                   base::do.call(base::Sys.setenv, args = args)
[17:29:44.312]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:44.312]             }
[17:29:44.312]             else {
[17:29:44.312]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:44.312]             }
[17:29:44.312]             {
[17:29:44.312]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:44.312]                   0L) {
[17:29:44.312]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:44.312]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:44.312]                   base::options(opts)
[17:29:44.312]                 }
[17:29:44.312]                 {
[17:29:44.312]                   {
[17:29:44.312]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:44.312]                     NULL
[17:29:44.312]                   }
[17:29:44.312]                   options(future.plan = NULL)
[17:29:44.312]                   if (is.na(NA_character_)) 
[17:29:44.312]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:44.312]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:44.312]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:44.312]                     .init = FALSE)
[17:29:44.312]                 }
[17:29:44.312]             }
[17:29:44.312]         }
[17:29:44.312]     })
[17:29:44.312]     if (TRUE) {
[17:29:44.312]         base::sink(type = "output", split = FALSE)
[17:29:44.312]         if (TRUE) {
[17:29:44.312]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:44.312]         }
[17:29:44.312]         else {
[17:29:44.312]             ...future.result["stdout"] <- base::list(NULL)
[17:29:44.312]         }
[17:29:44.312]         base::close(...future.stdout)
[17:29:44.312]         ...future.stdout <- NULL
[17:29:44.312]     }
[17:29:44.312]     ...future.result$conditions <- ...future.conditions
[17:29:44.312]     ...future.result$finished <- base::Sys.time()
[17:29:44.312]     ...future.result
[17:29:44.312] }
[17:29:44.467] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:44.467] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:44.468] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:44.469] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:44.470] MultisessionFuture started
[17:29:44.470] - Launch lazy future ... done
[17:29:44.470] run() for 'MultisessionFuture' ... done
[17:29:44.471] getGlobalsAndPackages() ...
[17:29:44.471] Searching for globals...
[17:29:44.473] - globals found: [3] '{', 'sample', 'x'
[17:29:44.473] Searching for globals ... DONE
[17:29:44.474] Resolving globals: FALSE
[17:29:44.474] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:44.475] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:44.475] - globals: [1] 'x'
[17:29:44.476] 
[17:29:44.476] getGlobalsAndPackages() ... DONE
[17:29:44.476] run() for 'Future' ...
[17:29:44.477] - state: 'created'
[17:29:44.477] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:44.499] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:44.499] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:44.500]   - Field: 'node'
[17:29:44.500]   - Field: 'label'
[17:29:44.500]   - Field: 'local'
[17:29:44.501]   - Field: 'owner'
[17:29:44.501]   - Field: 'envir'
[17:29:44.501]   - Field: 'workers'
[17:29:44.501]   - Field: 'packages'
[17:29:44.502]   - Field: 'gc'
[17:29:44.502]   - Field: 'conditions'
[17:29:44.502]   - Field: 'persistent'
[17:29:44.503]   - Field: 'expr'
[17:29:44.503]   - Field: 'uuid'
[17:29:44.503]   - Field: 'seed'
[17:29:44.503]   - Field: 'version'
[17:29:44.504]   - Field: 'result'
[17:29:44.504]   - Field: 'asynchronous'
[17:29:44.504]   - Field: 'calls'
[17:29:44.505]   - Field: 'globals'
[17:29:44.505]   - Field: 'stdout'
[17:29:44.505]   - Field: 'earlySignal'
[17:29:44.505]   - Field: 'lazy'
[17:29:44.506]   - Field: 'state'
[17:29:44.506] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:44.506] - Launch lazy future ...
[17:29:44.507] Packages needed by the future expression (n = 0): <none>
[17:29:44.507] Packages needed by future strategies (n = 0): <none>
[17:29:44.508] {
[17:29:44.508]     {
[17:29:44.508]         {
[17:29:44.508]             ...future.startTime <- base::Sys.time()
[17:29:44.508]             {
[17:29:44.508]                 {
[17:29:44.508]                   {
[17:29:44.508]                     {
[17:29:44.508]                       {
[17:29:44.508]                         base::local({
[17:29:44.508]                           has_future <- base::requireNamespace("future", 
[17:29:44.508]                             quietly = TRUE)
[17:29:44.508]                           if (has_future) {
[17:29:44.508]                             ns <- base::getNamespace("future")
[17:29:44.508]                             version <- ns[[".package"]][["version"]]
[17:29:44.508]                             if (is.null(version)) 
[17:29:44.508]                               version <- utils::packageVersion("future")
[17:29:44.508]                           }
[17:29:44.508]                           else {
[17:29:44.508]                             version <- NULL
[17:29:44.508]                           }
[17:29:44.508]                           if (!has_future || version < "1.8.0") {
[17:29:44.508]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:44.508]                               "", base::R.version$version.string), 
[17:29:44.508]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:44.508]                                 base::R.version$platform, 8 * 
[17:29:44.508]                                   base::.Machine$sizeof.pointer), 
[17:29:44.508]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:44.508]                                 "release", "version")], collapse = " "), 
[17:29:44.508]                               hostname = base::Sys.info()[["nodename"]])
[17:29:44.508]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:44.508]                               info)
[17:29:44.508]                             info <- base::paste(info, collapse = "; ")
[17:29:44.508]                             if (!has_future) {
[17:29:44.508]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:44.508]                                 info)
[17:29:44.508]                             }
[17:29:44.508]                             else {
[17:29:44.508]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:44.508]                                 info, version)
[17:29:44.508]                             }
[17:29:44.508]                             base::stop(msg)
[17:29:44.508]                           }
[17:29:44.508]                         })
[17:29:44.508]                       }
[17:29:44.508]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:44.508]                       base::options(mc.cores = 1L)
[17:29:44.508]                     }
[17:29:44.508]                     ...future.strategy.old <- future::plan("list")
[17:29:44.508]                     options(future.plan = NULL)
[17:29:44.508]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:44.508]                     future::plan("default", .cleanup = FALSE, 
[17:29:44.508]                       .init = FALSE)
[17:29:44.508]                   }
[17:29:44.508]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[17:29:44.508]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[17:29:44.508]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[17:29:44.508]                 }
[17:29:44.508]                 ...future.workdir <- getwd()
[17:29:44.508]             }
[17:29:44.508]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:44.508]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:44.508]         }
[17:29:44.508]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:44.508]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:44.508]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:44.508]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:44.508]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:44.508]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:44.508]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:44.508]             base::names(...future.oldOptions))
[17:29:44.508]     }
[17:29:44.508]     if (FALSE) {
[17:29:44.508]     }
[17:29:44.508]     else {
[17:29:44.508]         if (TRUE) {
[17:29:44.508]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:44.508]                 open = "w")
[17:29:44.508]         }
[17:29:44.508]         else {
[17:29:44.508]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:44.508]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:44.508]         }
[17:29:44.508]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:44.508]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:44.508]             base::sink(type = "output", split = FALSE)
[17:29:44.508]             base::close(...future.stdout)
[17:29:44.508]         }, add = TRUE)
[17:29:44.508]     }
[17:29:44.508]     ...future.frame <- base::sys.nframe()
[17:29:44.508]     ...future.conditions <- base::list()
[17:29:44.508]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:44.508]     if (FALSE) {
[17:29:44.508]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:44.508]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:44.508]     }
[17:29:44.508]     ...future.result <- base::tryCatch({
[17:29:44.508]         base::withCallingHandlers({
[17:29:44.508]             ...future.value <- base::withVisible(base::local({
[17:29:44.508]                 ...future.makeSendCondition <- base::local({
[17:29:44.508]                   sendCondition <- NULL
[17:29:44.508]                   function(frame = 1L) {
[17:29:44.508]                     if (is.function(sendCondition)) 
[17:29:44.508]                       return(sendCondition)
[17:29:44.508]                     ns <- getNamespace("parallel")
[17:29:44.508]                     if (exists("sendData", mode = "function", 
[17:29:44.508]                       envir = ns)) {
[17:29:44.508]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:44.508]                         envir = ns)
[17:29:44.508]                       envir <- sys.frame(frame)
[17:29:44.508]                       master <- NULL
[17:29:44.508]                       while (!identical(envir, .GlobalEnv) && 
[17:29:44.508]                         !identical(envir, emptyenv())) {
[17:29:44.508]                         if (exists("master", mode = "list", envir = envir, 
[17:29:44.508]                           inherits = FALSE)) {
[17:29:44.508]                           master <- get("master", mode = "list", 
[17:29:44.508]                             envir = envir, inherits = FALSE)
[17:29:44.508]                           if (inherits(master, c("SOCKnode", 
[17:29:44.508]                             "SOCK0node"))) {
[17:29:44.508]                             sendCondition <<- function(cond) {
[17:29:44.508]                               data <- list(type = "VALUE", value = cond, 
[17:29:44.508]                                 success = TRUE)
[17:29:44.508]                               parallel_sendData(master, data)
[17:29:44.508]                             }
[17:29:44.508]                             return(sendCondition)
[17:29:44.508]                           }
[17:29:44.508]                         }
[17:29:44.508]                         frame <- frame + 1L
[17:29:44.508]                         envir <- sys.frame(frame)
[17:29:44.508]                       }
[17:29:44.508]                     }
[17:29:44.508]                     sendCondition <<- function(cond) NULL
[17:29:44.508]                   }
[17:29:44.508]                 })
[17:29:44.508]                 withCallingHandlers({
[17:29:44.508]                   {
[17:29:44.508]                     sample(x, size = 1L)
[17:29:44.508]                   }
[17:29:44.508]                 }, immediateCondition = function(cond) {
[17:29:44.508]                   sendCondition <- ...future.makeSendCondition()
[17:29:44.508]                   sendCondition(cond)
[17:29:44.508]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.508]                   {
[17:29:44.508]                     inherits <- base::inherits
[17:29:44.508]                     invokeRestart <- base::invokeRestart
[17:29:44.508]                     is.null <- base::is.null
[17:29:44.508]                     muffled <- FALSE
[17:29:44.508]                     if (inherits(cond, "message")) {
[17:29:44.508]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:44.508]                       if (muffled) 
[17:29:44.508]                         invokeRestart("muffleMessage")
[17:29:44.508]                     }
[17:29:44.508]                     else if (inherits(cond, "warning")) {
[17:29:44.508]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:44.508]                       if (muffled) 
[17:29:44.508]                         invokeRestart("muffleWarning")
[17:29:44.508]                     }
[17:29:44.508]                     else if (inherits(cond, "condition")) {
[17:29:44.508]                       if (!is.null(pattern)) {
[17:29:44.508]                         computeRestarts <- base::computeRestarts
[17:29:44.508]                         grepl <- base::grepl
[17:29:44.508]                         restarts <- computeRestarts(cond)
[17:29:44.508]                         for (restart in restarts) {
[17:29:44.508]                           name <- restart$name
[17:29:44.508]                           if (is.null(name)) 
[17:29:44.508]                             next
[17:29:44.508]                           if (!grepl(pattern, name)) 
[17:29:44.508]                             next
[17:29:44.508]                           invokeRestart(restart)
[17:29:44.508]                           muffled <- TRUE
[17:29:44.508]                           break
[17:29:44.508]                         }
[17:29:44.508]                       }
[17:29:44.508]                     }
[17:29:44.508]                     invisible(muffled)
[17:29:44.508]                   }
[17:29:44.508]                   muffleCondition(cond)
[17:29:44.508]                 })
[17:29:44.508]             }))
[17:29:44.508]             future::FutureResult(value = ...future.value$value, 
[17:29:44.508]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:44.508]                   ...future.rng), globalenv = if (FALSE) 
[17:29:44.508]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:44.508]                     ...future.globalenv.names))
[17:29:44.508]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:44.508]         }, condition = base::local({
[17:29:44.508]             c <- base::c
[17:29:44.508]             inherits <- base::inherits
[17:29:44.508]             invokeRestart <- base::invokeRestart
[17:29:44.508]             length <- base::length
[17:29:44.508]             list <- base::list
[17:29:44.508]             seq.int <- base::seq.int
[17:29:44.508]             signalCondition <- base::signalCondition
[17:29:44.508]             sys.calls <- base::sys.calls
[17:29:44.508]             `[[` <- base::`[[`
[17:29:44.508]             `+` <- base::`+`
[17:29:44.508]             `<<-` <- base::`<<-`
[17:29:44.508]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:44.508]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:44.508]                   3L)]
[17:29:44.508]             }
[17:29:44.508]             function(cond) {
[17:29:44.508]                 is_error <- inherits(cond, "error")
[17:29:44.508]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:44.508]                   NULL)
[17:29:44.508]                 if (is_error) {
[17:29:44.508]                   sessionInformation <- function() {
[17:29:44.508]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:44.508]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:44.508]                       search = base::search(), system = base::Sys.info())
[17:29:44.508]                   }
[17:29:44.508]                   ...future.conditions[[length(...future.conditions) + 
[17:29:44.508]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:44.508]                     cond$call), session = sessionInformation(), 
[17:29:44.508]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:44.508]                   signalCondition(cond)
[17:29:44.508]                 }
[17:29:44.508]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:44.508]                 "immediateCondition"))) {
[17:29:44.508]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:44.508]                   ...future.conditions[[length(...future.conditions) + 
[17:29:44.508]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:44.508]                   if (TRUE && !signal) {
[17:29:44.508]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.508]                     {
[17:29:44.508]                       inherits <- base::inherits
[17:29:44.508]                       invokeRestart <- base::invokeRestart
[17:29:44.508]                       is.null <- base::is.null
[17:29:44.508]                       muffled <- FALSE
[17:29:44.508]                       if (inherits(cond, "message")) {
[17:29:44.508]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:44.508]                         if (muffled) 
[17:29:44.508]                           invokeRestart("muffleMessage")
[17:29:44.508]                       }
[17:29:44.508]                       else if (inherits(cond, "warning")) {
[17:29:44.508]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:44.508]                         if (muffled) 
[17:29:44.508]                           invokeRestart("muffleWarning")
[17:29:44.508]                       }
[17:29:44.508]                       else if (inherits(cond, "condition")) {
[17:29:44.508]                         if (!is.null(pattern)) {
[17:29:44.508]                           computeRestarts <- base::computeRestarts
[17:29:44.508]                           grepl <- base::grepl
[17:29:44.508]                           restarts <- computeRestarts(cond)
[17:29:44.508]                           for (restart in restarts) {
[17:29:44.508]                             name <- restart$name
[17:29:44.508]                             if (is.null(name)) 
[17:29:44.508]                               next
[17:29:44.508]                             if (!grepl(pattern, name)) 
[17:29:44.508]                               next
[17:29:44.508]                             invokeRestart(restart)
[17:29:44.508]                             muffled <- TRUE
[17:29:44.508]                             break
[17:29:44.508]                           }
[17:29:44.508]                         }
[17:29:44.508]                       }
[17:29:44.508]                       invisible(muffled)
[17:29:44.508]                     }
[17:29:44.508]                     muffleCondition(cond, pattern = "^muffle")
[17:29:44.508]                   }
[17:29:44.508]                 }
[17:29:44.508]                 else {
[17:29:44.508]                   if (TRUE) {
[17:29:44.508]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.508]                     {
[17:29:44.508]                       inherits <- base::inherits
[17:29:44.508]                       invokeRestart <- base::invokeRestart
[17:29:44.508]                       is.null <- base::is.null
[17:29:44.508]                       muffled <- FALSE
[17:29:44.508]                       if (inherits(cond, "message")) {
[17:29:44.508]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:44.508]                         if (muffled) 
[17:29:44.508]                           invokeRestart("muffleMessage")
[17:29:44.508]                       }
[17:29:44.508]                       else if (inherits(cond, "warning")) {
[17:29:44.508]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:44.508]                         if (muffled) 
[17:29:44.508]                           invokeRestart("muffleWarning")
[17:29:44.508]                       }
[17:29:44.508]                       else if (inherits(cond, "condition")) {
[17:29:44.508]                         if (!is.null(pattern)) {
[17:29:44.508]                           computeRestarts <- base::computeRestarts
[17:29:44.508]                           grepl <- base::grepl
[17:29:44.508]                           restarts <- computeRestarts(cond)
[17:29:44.508]                           for (restart in restarts) {
[17:29:44.508]                             name <- restart$name
[17:29:44.508]                             if (is.null(name)) 
[17:29:44.508]                               next
[17:29:44.508]                             if (!grepl(pattern, name)) 
[17:29:44.508]                               next
[17:29:44.508]                             invokeRestart(restart)
[17:29:44.508]                             muffled <- TRUE
[17:29:44.508]                             break
[17:29:44.508]                           }
[17:29:44.508]                         }
[17:29:44.508]                       }
[17:29:44.508]                       invisible(muffled)
[17:29:44.508]                     }
[17:29:44.508]                     muffleCondition(cond, pattern = "^muffle")
[17:29:44.508]                   }
[17:29:44.508]                 }
[17:29:44.508]             }
[17:29:44.508]         }))
[17:29:44.508]     }, error = function(ex) {
[17:29:44.508]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:44.508]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:44.508]                 ...future.rng), started = ...future.startTime, 
[17:29:44.508]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:44.508]             version = "1.8"), class = "FutureResult")
[17:29:44.508]     }, finally = {
[17:29:44.508]         if (!identical(...future.workdir, getwd())) 
[17:29:44.508]             setwd(...future.workdir)
[17:29:44.508]         {
[17:29:44.508]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:44.508]                 ...future.oldOptions$nwarnings <- NULL
[17:29:44.508]             }
[17:29:44.508]             base::options(...future.oldOptions)
[17:29:44.508]             if (.Platform$OS.type == "windows") {
[17:29:44.508]                 old_names <- names(...future.oldEnvVars)
[17:29:44.508]                 envs <- base::Sys.getenv()
[17:29:44.508]                 names <- names(envs)
[17:29:44.508]                 common <- intersect(names, old_names)
[17:29:44.508]                 added <- setdiff(names, old_names)
[17:29:44.508]                 removed <- setdiff(old_names, names)
[17:29:44.508]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:44.508]                   envs[common]]
[17:29:44.508]                 NAMES <- toupper(changed)
[17:29:44.508]                 args <- list()
[17:29:44.508]                 for (kk in seq_along(NAMES)) {
[17:29:44.508]                   name <- changed[[kk]]
[17:29:44.508]                   NAME <- NAMES[[kk]]
[17:29:44.508]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.508]                     next
[17:29:44.508]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:44.508]                 }
[17:29:44.508]                 NAMES <- toupper(added)
[17:29:44.508]                 for (kk in seq_along(NAMES)) {
[17:29:44.508]                   name <- added[[kk]]
[17:29:44.508]                   NAME <- NAMES[[kk]]
[17:29:44.508]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.508]                     next
[17:29:44.508]                   args[[name]] <- ""
[17:29:44.508]                 }
[17:29:44.508]                 NAMES <- toupper(removed)
[17:29:44.508]                 for (kk in seq_along(NAMES)) {
[17:29:44.508]                   name <- removed[[kk]]
[17:29:44.508]                   NAME <- NAMES[[kk]]
[17:29:44.508]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.508]                     next
[17:29:44.508]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:44.508]                 }
[17:29:44.508]                 if (length(args) > 0) 
[17:29:44.508]                   base::do.call(base::Sys.setenv, args = args)
[17:29:44.508]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:44.508]             }
[17:29:44.508]             else {
[17:29:44.508]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:44.508]             }
[17:29:44.508]             {
[17:29:44.508]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:44.508]                   0L) {
[17:29:44.508]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:44.508]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:44.508]                   base::options(opts)
[17:29:44.508]                 }
[17:29:44.508]                 {
[17:29:44.508]                   {
[17:29:44.508]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:44.508]                     NULL
[17:29:44.508]                   }
[17:29:44.508]                   options(future.plan = NULL)
[17:29:44.508]                   if (is.na(NA_character_)) 
[17:29:44.508]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:44.508]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:44.508]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:44.508]                     .init = FALSE)
[17:29:44.508]                 }
[17:29:44.508]             }
[17:29:44.508]         }
[17:29:44.508]     })
[17:29:44.508]     if (TRUE) {
[17:29:44.508]         base::sink(type = "output", split = FALSE)
[17:29:44.508]         if (TRUE) {
[17:29:44.508]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:44.508]         }
[17:29:44.508]         else {
[17:29:44.508]             ...future.result["stdout"] <- base::list(NULL)
[17:29:44.508]         }
[17:29:44.508]         base::close(...future.stdout)
[17:29:44.508]         ...future.stdout <- NULL
[17:29:44.508]     }
[17:29:44.508]     ...future.result$conditions <- ...future.conditions
[17:29:44.508]     ...future.result$finished <- base::Sys.time()
[17:29:44.508]     ...future.result
[17:29:44.508] }
[17:29:44.515] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:44.536] receiveMessageFromWorker() for ClusterFuture ...
[17:29:44.536] - Validating connection of MultisessionFuture
[17:29:44.536] - received message: FutureResult
[17:29:44.537] - Received FutureResult
[17:29:44.537] - Erased future from FutureRegistry
[17:29:44.537] result() for ClusterFuture ...
[17:29:44.537] - result already collected: FutureResult
[17:29:44.538] result() for ClusterFuture ... done
[17:29:44.538] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:44.538] result() for ClusterFuture ...
[17:29:44.539] - result already collected: FutureResult
[17:29:44.539] result() for ClusterFuture ... done
[17:29:44.539] result() for ClusterFuture ...
[17:29:44.539] - result already collected: FutureResult
[17:29:44.540] result() for ClusterFuture ... done
[17:29:44.541] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:44.541] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:44.542] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:44.542] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:44.543] MultisessionFuture started
[17:29:44.543] - Launch lazy future ... done
[17:29:44.544] run() for 'MultisessionFuture' ... done
[17:29:44.544] getGlobalsAndPackages() ...
[17:29:44.544] Searching for globals...
[17:29:44.546] - globals found: [3] '{', 'sample', 'x'
[17:29:44.547] Searching for globals ... DONE
[17:29:44.547] Resolving globals: FALSE
[17:29:44.548] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:44.548] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:44.549] - globals: [1] 'x'
[17:29:44.549] 
[17:29:44.549] getGlobalsAndPackages() ... DONE
[17:29:44.550] run() for 'Future' ...
[17:29:44.550] - state: 'created'
[17:29:44.550] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:44.573] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:44.573] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:44.574]   - Field: 'node'
[17:29:44.574]   - Field: 'label'
[17:29:44.574]   - Field: 'local'
[17:29:44.574]   - Field: 'owner'
[17:29:44.575]   - Field: 'envir'
[17:29:44.575]   - Field: 'workers'
[17:29:44.575]   - Field: 'packages'
[17:29:44.576]   - Field: 'gc'
[17:29:44.576]   - Field: 'conditions'
[17:29:44.576]   - Field: 'persistent'
[17:29:44.576]   - Field: 'expr'
[17:29:44.577]   - Field: 'uuid'
[17:29:44.577]   - Field: 'seed'
[17:29:44.577]   - Field: 'version'
[17:29:44.578]   - Field: 'result'
[17:29:44.578]   - Field: 'asynchronous'
[17:29:44.578]   - Field: 'calls'
[17:29:44.578]   - Field: 'globals'
[17:29:44.579]   - Field: 'stdout'
[17:29:44.579]   - Field: 'earlySignal'
[17:29:44.579]   - Field: 'lazy'
[17:29:44.579]   - Field: 'state'
[17:29:44.580] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:44.580] - Launch lazy future ...
[17:29:44.581] Packages needed by the future expression (n = 0): <none>
[17:29:44.581] Packages needed by future strategies (n = 0): <none>
[17:29:44.582] {
[17:29:44.582]     {
[17:29:44.582]         {
[17:29:44.582]             ...future.startTime <- base::Sys.time()
[17:29:44.582]             {
[17:29:44.582]                 {
[17:29:44.582]                   {
[17:29:44.582]                     {
[17:29:44.582]                       {
[17:29:44.582]                         base::local({
[17:29:44.582]                           has_future <- base::requireNamespace("future", 
[17:29:44.582]                             quietly = TRUE)
[17:29:44.582]                           if (has_future) {
[17:29:44.582]                             ns <- base::getNamespace("future")
[17:29:44.582]                             version <- ns[[".package"]][["version"]]
[17:29:44.582]                             if (is.null(version)) 
[17:29:44.582]                               version <- utils::packageVersion("future")
[17:29:44.582]                           }
[17:29:44.582]                           else {
[17:29:44.582]                             version <- NULL
[17:29:44.582]                           }
[17:29:44.582]                           if (!has_future || version < "1.8.0") {
[17:29:44.582]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:44.582]                               "", base::R.version$version.string), 
[17:29:44.582]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:44.582]                                 base::R.version$platform, 8 * 
[17:29:44.582]                                   base::.Machine$sizeof.pointer), 
[17:29:44.582]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:44.582]                                 "release", "version")], collapse = " "), 
[17:29:44.582]                               hostname = base::Sys.info()[["nodename"]])
[17:29:44.582]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:44.582]                               info)
[17:29:44.582]                             info <- base::paste(info, collapse = "; ")
[17:29:44.582]                             if (!has_future) {
[17:29:44.582]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:44.582]                                 info)
[17:29:44.582]                             }
[17:29:44.582]                             else {
[17:29:44.582]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:44.582]                                 info, version)
[17:29:44.582]                             }
[17:29:44.582]                             base::stop(msg)
[17:29:44.582]                           }
[17:29:44.582]                         })
[17:29:44.582]                       }
[17:29:44.582]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:44.582]                       base::options(mc.cores = 1L)
[17:29:44.582]                     }
[17:29:44.582]                     ...future.strategy.old <- future::plan("list")
[17:29:44.582]                     options(future.plan = NULL)
[17:29:44.582]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:44.582]                     future::plan("default", .cleanup = FALSE, 
[17:29:44.582]                       .init = FALSE)
[17:29:44.582]                   }
[17:29:44.582]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[17:29:44.582]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[17:29:44.582]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[17:29:44.582]                 }
[17:29:44.582]                 ...future.workdir <- getwd()
[17:29:44.582]             }
[17:29:44.582]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:44.582]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:44.582]         }
[17:29:44.582]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:44.582]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:44.582]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:44.582]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:44.582]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:44.582]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:44.582]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:44.582]             base::names(...future.oldOptions))
[17:29:44.582]     }
[17:29:44.582]     if (FALSE) {
[17:29:44.582]     }
[17:29:44.582]     else {
[17:29:44.582]         if (TRUE) {
[17:29:44.582]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:44.582]                 open = "w")
[17:29:44.582]         }
[17:29:44.582]         else {
[17:29:44.582]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:44.582]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:44.582]         }
[17:29:44.582]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:44.582]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:44.582]             base::sink(type = "output", split = FALSE)
[17:29:44.582]             base::close(...future.stdout)
[17:29:44.582]         }, add = TRUE)
[17:29:44.582]     }
[17:29:44.582]     ...future.frame <- base::sys.nframe()
[17:29:44.582]     ...future.conditions <- base::list()
[17:29:44.582]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:44.582]     if (FALSE) {
[17:29:44.582]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:44.582]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:44.582]     }
[17:29:44.582]     ...future.result <- base::tryCatch({
[17:29:44.582]         base::withCallingHandlers({
[17:29:44.582]             ...future.value <- base::withVisible(base::local({
[17:29:44.582]                 ...future.makeSendCondition <- base::local({
[17:29:44.582]                   sendCondition <- NULL
[17:29:44.582]                   function(frame = 1L) {
[17:29:44.582]                     if (is.function(sendCondition)) 
[17:29:44.582]                       return(sendCondition)
[17:29:44.582]                     ns <- getNamespace("parallel")
[17:29:44.582]                     if (exists("sendData", mode = "function", 
[17:29:44.582]                       envir = ns)) {
[17:29:44.582]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:44.582]                         envir = ns)
[17:29:44.582]                       envir <- sys.frame(frame)
[17:29:44.582]                       master <- NULL
[17:29:44.582]                       while (!identical(envir, .GlobalEnv) && 
[17:29:44.582]                         !identical(envir, emptyenv())) {
[17:29:44.582]                         if (exists("master", mode = "list", envir = envir, 
[17:29:44.582]                           inherits = FALSE)) {
[17:29:44.582]                           master <- get("master", mode = "list", 
[17:29:44.582]                             envir = envir, inherits = FALSE)
[17:29:44.582]                           if (inherits(master, c("SOCKnode", 
[17:29:44.582]                             "SOCK0node"))) {
[17:29:44.582]                             sendCondition <<- function(cond) {
[17:29:44.582]                               data <- list(type = "VALUE", value = cond, 
[17:29:44.582]                                 success = TRUE)
[17:29:44.582]                               parallel_sendData(master, data)
[17:29:44.582]                             }
[17:29:44.582]                             return(sendCondition)
[17:29:44.582]                           }
[17:29:44.582]                         }
[17:29:44.582]                         frame <- frame + 1L
[17:29:44.582]                         envir <- sys.frame(frame)
[17:29:44.582]                       }
[17:29:44.582]                     }
[17:29:44.582]                     sendCondition <<- function(cond) NULL
[17:29:44.582]                   }
[17:29:44.582]                 })
[17:29:44.582]                 withCallingHandlers({
[17:29:44.582]                   {
[17:29:44.582]                     sample(x, size = 1L)
[17:29:44.582]                   }
[17:29:44.582]                 }, immediateCondition = function(cond) {
[17:29:44.582]                   sendCondition <- ...future.makeSendCondition()
[17:29:44.582]                   sendCondition(cond)
[17:29:44.582]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.582]                   {
[17:29:44.582]                     inherits <- base::inherits
[17:29:44.582]                     invokeRestart <- base::invokeRestart
[17:29:44.582]                     is.null <- base::is.null
[17:29:44.582]                     muffled <- FALSE
[17:29:44.582]                     if (inherits(cond, "message")) {
[17:29:44.582]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:44.582]                       if (muffled) 
[17:29:44.582]                         invokeRestart("muffleMessage")
[17:29:44.582]                     }
[17:29:44.582]                     else if (inherits(cond, "warning")) {
[17:29:44.582]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:44.582]                       if (muffled) 
[17:29:44.582]                         invokeRestart("muffleWarning")
[17:29:44.582]                     }
[17:29:44.582]                     else if (inherits(cond, "condition")) {
[17:29:44.582]                       if (!is.null(pattern)) {
[17:29:44.582]                         computeRestarts <- base::computeRestarts
[17:29:44.582]                         grepl <- base::grepl
[17:29:44.582]                         restarts <- computeRestarts(cond)
[17:29:44.582]                         for (restart in restarts) {
[17:29:44.582]                           name <- restart$name
[17:29:44.582]                           if (is.null(name)) 
[17:29:44.582]                             next
[17:29:44.582]                           if (!grepl(pattern, name)) 
[17:29:44.582]                             next
[17:29:44.582]                           invokeRestart(restart)
[17:29:44.582]                           muffled <- TRUE
[17:29:44.582]                           break
[17:29:44.582]                         }
[17:29:44.582]                       }
[17:29:44.582]                     }
[17:29:44.582]                     invisible(muffled)
[17:29:44.582]                   }
[17:29:44.582]                   muffleCondition(cond)
[17:29:44.582]                 })
[17:29:44.582]             }))
[17:29:44.582]             future::FutureResult(value = ...future.value$value, 
[17:29:44.582]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:44.582]                   ...future.rng), globalenv = if (FALSE) 
[17:29:44.582]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:44.582]                     ...future.globalenv.names))
[17:29:44.582]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:44.582]         }, condition = base::local({
[17:29:44.582]             c <- base::c
[17:29:44.582]             inherits <- base::inherits
[17:29:44.582]             invokeRestart <- base::invokeRestart
[17:29:44.582]             length <- base::length
[17:29:44.582]             list <- base::list
[17:29:44.582]             seq.int <- base::seq.int
[17:29:44.582]             signalCondition <- base::signalCondition
[17:29:44.582]             sys.calls <- base::sys.calls
[17:29:44.582]             `[[` <- base::`[[`
[17:29:44.582]             `+` <- base::`+`
[17:29:44.582]             `<<-` <- base::`<<-`
[17:29:44.582]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:44.582]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:44.582]                   3L)]
[17:29:44.582]             }
[17:29:44.582]             function(cond) {
[17:29:44.582]                 is_error <- inherits(cond, "error")
[17:29:44.582]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:44.582]                   NULL)
[17:29:44.582]                 if (is_error) {
[17:29:44.582]                   sessionInformation <- function() {
[17:29:44.582]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:44.582]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:44.582]                       search = base::search(), system = base::Sys.info())
[17:29:44.582]                   }
[17:29:44.582]                   ...future.conditions[[length(...future.conditions) + 
[17:29:44.582]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:44.582]                     cond$call), session = sessionInformation(), 
[17:29:44.582]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:44.582]                   signalCondition(cond)
[17:29:44.582]                 }
[17:29:44.582]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:44.582]                 "immediateCondition"))) {
[17:29:44.582]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:44.582]                   ...future.conditions[[length(...future.conditions) + 
[17:29:44.582]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:44.582]                   if (TRUE && !signal) {
[17:29:44.582]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.582]                     {
[17:29:44.582]                       inherits <- base::inherits
[17:29:44.582]                       invokeRestart <- base::invokeRestart
[17:29:44.582]                       is.null <- base::is.null
[17:29:44.582]                       muffled <- FALSE
[17:29:44.582]                       if (inherits(cond, "message")) {
[17:29:44.582]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:44.582]                         if (muffled) 
[17:29:44.582]                           invokeRestart("muffleMessage")
[17:29:44.582]                       }
[17:29:44.582]                       else if (inherits(cond, "warning")) {
[17:29:44.582]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:44.582]                         if (muffled) 
[17:29:44.582]                           invokeRestart("muffleWarning")
[17:29:44.582]                       }
[17:29:44.582]                       else if (inherits(cond, "condition")) {
[17:29:44.582]                         if (!is.null(pattern)) {
[17:29:44.582]                           computeRestarts <- base::computeRestarts
[17:29:44.582]                           grepl <- base::grepl
[17:29:44.582]                           restarts <- computeRestarts(cond)
[17:29:44.582]                           for (restart in restarts) {
[17:29:44.582]                             name <- restart$name
[17:29:44.582]                             if (is.null(name)) 
[17:29:44.582]                               next
[17:29:44.582]                             if (!grepl(pattern, name)) 
[17:29:44.582]                               next
[17:29:44.582]                             invokeRestart(restart)
[17:29:44.582]                             muffled <- TRUE
[17:29:44.582]                             break
[17:29:44.582]                           }
[17:29:44.582]                         }
[17:29:44.582]                       }
[17:29:44.582]                       invisible(muffled)
[17:29:44.582]                     }
[17:29:44.582]                     muffleCondition(cond, pattern = "^muffle")
[17:29:44.582]                   }
[17:29:44.582]                 }
[17:29:44.582]                 else {
[17:29:44.582]                   if (TRUE) {
[17:29:44.582]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.582]                     {
[17:29:44.582]                       inherits <- base::inherits
[17:29:44.582]                       invokeRestart <- base::invokeRestart
[17:29:44.582]                       is.null <- base::is.null
[17:29:44.582]                       muffled <- FALSE
[17:29:44.582]                       if (inherits(cond, "message")) {
[17:29:44.582]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:44.582]                         if (muffled) 
[17:29:44.582]                           invokeRestart("muffleMessage")
[17:29:44.582]                       }
[17:29:44.582]                       else if (inherits(cond, "warning")) {
[17:29:44.582]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:44.582]                         if (muffled) 
[17:29:44.582]                           invokeRestart("muffleWarning")
[17:29:44.582]                       }
[17:29:44.582]                       else if (inherits(cond, "condition")) {
[17:29:44.582]                         if (!is.null(pattern)) {
[17:29:44.582]                           computeRestarts <- base::computeRestarts
[17:29:44.582]                           grepl <- base::grepl
[17:29:44.582]                           restarts <- computeRestarts(cond)
[17:29:44.582]                           for (restart in restarts) {
[17:29:44.582]                             name <- restart$name
[17:29:44.582]                             if (is.null(name)) 
[17:29:44.582]                               next
[17:29:44.582]                             if (!grepl(pattern, name)) 
[17:29:44.582]                               next
[17:29:44.582]                             invokeRestart(restart)
[17:29:44.582]                             muffled <- TRUE
[17:29:44.582]                             break
[17:29:44.582]                           }
[17:29:44.582]                         }
[17:29:44.582]                       }
[17:29:44.582]                       invisible(muffled)
[17:29:44.582]                     }
[17:29:44.582]                     muffleCondition(cond, pattern = "^muffle")
[17:29:44.582]                   }
[17:29:44.582]                 }
[17:29:44.582]             }
[17:29:44.582]         }))
[17:29:44.582]     }, error = function(ex) {
[17:29:44.582]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:44.582]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:44.582]                 ...future.rng), started = ...future.startTime, 
[17:29:44.582]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:44.582]             version = "1.8"), class = "FutureResult")
[17:29:44.582]     }, finally = {
[17:29:44.582]         if (!identical(...future.workdir, getwd())) 
[17:29:44.582]             setwd(...future.workdir)
[17:29:44.582]         {
[17:29:44.582]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:44.582]                 ...future.oldOptions$nwarnings <- NULL
[17:29:44.582]             }
[17:29:44.582]             base::options(...future.oldOptions)
[17:29:44.582]             if (.Platform$OS.type == "windows") {
[17:29:44.582]                 old_names <- names(...future.oldEnvVars)
[17:29:44.582]                 envs <- base::Sys.getenv()
[17:29:44.582]                 names <- names(envs)
[17:29:44.582]                 common <- intersect(names, old_names)
[17:29:44.582]                 added <- setdiff(names, old_names)
[17:29:44.582]                 removed <- setdiff(old_names, names)
[17:29:44.582]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:44.582]                   envs[common]]
[17:29:44.582]                 NAMES <- toupper(changed)
[17:29:44.582]                 args <- list()
[17:29:44.582]                 for (kk in seq_along(NAMES)) {
[17:29:44.582]                   name <- changed[[kk]]
[17:29:44.582]                   NAME <- NAMES[[kk]]
[17:29:44.582]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.582]                     next
[17:29:44.582]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:44.582]                 }
[17:29:44.582]                 NAMES <- toupper(added)
[17:29:44.582]                 for (kk in seq_along(NAMES)) {
[17:29:44.582]                   name <- added[[kk]]
[17:29:44.582]                   NAME <- NAMES[[kk]]
[17:29:44.582]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.582]                     next
[17:29:44.582]                   args[[name]] <- ""
[17:29:44.582]                 }
[17:29:44.582]                 NAMES <- toupper(removed)
[17:29:44.582]                 for (kk in seq_along(NAMES)) {
[17:29:44.582]                   name <- removed[[kk]]
[17:29:44.582]                   NAME <- NAMES[[kk]]
[17:29:44.582]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.582]                     next
[17:29:44.582]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:44.582]                 }
[17:29:44.582]                 if (length(args) > 0) 
[17:29:44.582]                   base::do.call(base::Sys.setenv, args = args)
[17:29:44.582]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:44.582]             }
[17:29:44.582]             else {
[17:29:44.582]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:44.582]             }
[17:29:44.582]             {
[17:29:44.582]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:44.582]                   0L) {
[17:29:44.582]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:44.582]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:44.582]                   base::options(opts)
[17:29:44.582]                 }
[17:29:44.582]                 {
[17:29:44.582]                   {
[17:29:44.582]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:44.582]                     NULL
[17:29:44.582]                   }
[17:29:44.582]                   options(future.plan = NULL)
[17:29:44.582]                   if (is.na(NA_character_)) 
[17:29:44.582]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:44.582]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:44.582]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:44.582]                     .init = FALSE)
[17:29:44.582]                 }
[17:29:44.582]             }
[17:29:44.582]         }
[17:29:44.582]     })
[17:29:44.582]     if (TRUE) {
[17:29:44.582]         base::sink(type = "output", split = FALSE)
[17:29:44.582]         if (TRUE) {
[17:29:44.582]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:44.582]         }
[17:29:44.582]         else {
[17:29:44.582]             ...future.result["stdout"] <- base::list(NULL)
[17:29:44.582]         }
[17:29:44.582]         base::close(...future.stdout)
[17:29:44.582]         ...future.stdout <- NULL
[17:29:44.582]     }
[17:29:44.582]     ...future.result$conditions <- ...future.conditions
[17:29:44.582]     ...future.result$finished <- base::Sys.time()
[17:29:44.582]     ...future.result
[17:29:44.582] }
[17:29:44.588] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:44.630] receiveMessageFromWorker() for ClusterFuture ...
[17:29:44.631] - Validating connection of MultisessionFuture
[17:29:44.631] - received message: FutureResult
[17:29:44.631] - Received FutureResult
[17:29:44.632] - Erased future from FutureRegistry
[17:29:44.632] result() for ClusterFuture ...
[17:29:44.632] - result already collected: FutureResult
[17:29:44.633] result() for ClusterFuture ... done
[17:29:44.633] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:44.633] result() for ClusterFuture ...
[17:29:44.633] - result already collected: FutureResult
[17:29:44.634] result() for ClusterFuture ... done
[17:29:44.634] result() for ClusterFuture ...
[17:29:44.634] - result already collected: FutureResult
[17:29:44.634] result() for ClusterFuture ... done
[17:29:44.636] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:44.636] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:44.636] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:44.637] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:44.638] MultisessionFuture started
[17:29:44.638] - Launch lazy future ... done
[17:29:44.638] run() for 'MultisessionFuture' ... done
[17:29:44.638] resolve() on list ...
[17:29:44.639]  recursive: 0
[17:29:44.639]  length: 4
[17:29:44.639] 
[17:29:44.639] Future #1
[17:29:44.640] result() for ClusterFuture ...
[17:29:44.640] - result already collected: FutureResult
[17:29:44.640] result() for ClusterFuture ... done
[17:29:44.640] result() for ClusterFuture ...
[17:29:44.641] - result already collected: FutureResult
[17:29:44.641] result() for ClusterFuture ... done
[17:29:44.641] signalConditionsASAP(MultisessionFuture, pos=1) ...
[17:29:44.641] - nx: 4
[17:29:44.642] - relay: TRUE
[17:29:44.642] - stdout: TRUE
[17:29:44.642] - signal: TRUE
[17:29:44.642] - resignal: FALSE
[17:29:44.642] - force: TRUE
[17:29:44.643] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:44.643] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:44.643]  - until=1
[17:29:44.643]  - relaying element #1
[17:29:44.644] result() for ClusterFuture ...
[17:29:44.644] - result already collected: FutureResult
[17:29:44.644] result() for ClusterFuture ... done
[17:29:44.644] result() for ClusterFuture ...
[17:29:44.645] - result already collected: FutureResult
[17:29:44.645] result() for ClusterFuture ... done
[17:29:44.645] result() for ClusterFuture ...
[17:29:44.645] - result already collected: FutureResult
[17:29:44.646] result() for ClusterFuture ... done
[17:29:44.646] result() for ClusterFuture ...
[17:29:44.646] - result already collected: FutureResult
[17:29:44.646] result() for ClusterFuture ... done
[17:29:44.647] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:44.647] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:44.647] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[17:29:44.647]  length: 3 (resolved future 1)
[17:29:44.648] Future #2
[17:29:44.648] result() for ClusterFuture ...
[17:29:44.648] - result already collected: FutureResult
[17:29:44.648] result() for ClusterFuture ... done
[17:29:44.649] result() for ClusterFuture ...
[17:29:44.649] - result already collected: FutureResult
[17:29:44.649] result() for ClusterFuture ... done
[17:29:44.649] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:29:44.650] - nx: 4
[17:29:44.650] - relay: TRUE
[17:29:44.650] - stdout: TRUE
[17:29:44.650] - signal: TRUE
[17:29:44.651] - resignal: FALSE
[17:29:44.651] - force: TRUE
[17:29:44.651] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:44.651] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:44.652]  - until=2
[17:29:44.652]  - relaying element #2
[17:29:44.652] result() for ClusterFuture ...
[17:29:44.652] - result already collected: FutureResult
[17:29:44.652] result() for ClusterFuture ... done
[17:29:44.653] result() for ClusterFuture ...
[17:29:44.653] - result already collected: FutureResult
[17:29:44.653] result() for ClusterFuture ... done
[17:29:44.654] result() for ClusterFuture ...
[17:29:44.654] - result already collected: FutureResult
[17:29:44.654] result() for ClusterFuture ... done
[17:29:44.654] result() for ClusterFuture ...
[17:29:44.655] - result already collected: FutureResult
[17:29:44.655] result() for ClusterFuture ... done
[17:29:44.655] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:44.655] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:44.656] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:29:44.656]  length: 2 (resolved future 2)
[17:29:44.657] receiveMessageFromWorker() for ClusterFuture ...
[17:29:44.657] - Validating connection of MultisessionFuture
[17:29:44.658] - received message: FutureResult
[17:29:44.658] - Received FutureResult
[17:29:44.658] - Erased future from FutureRegistry
[17:29:44.659] result() for ClusterFuture ...
[17:29:44.659] - result already collected: FutureResult
[17:29:44.659] result() for ClusterFuture ... done
[17:29:44.660] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:44.660] Future #3
[17:29:44.660] result() for ClusterFuture ...
[17:29:44.660] - result already collected: FutureResult
[17:29:44.661] result() for ClusterFuture ... done
[17:29:44.661] result() for ClusterFuture ...
[17:29:44.661] - result already collected: FutureResult
[17:29:44.662] result() for ClusterFuture ... done
[17:29:44.662] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:29:44.662] - nx: 4
[17:29:44.663] - relay: TRUE
[17:29:44.663] - stdout: TRUE
[17:29:44.663] - signal: TRUE
[17:29:44.663] - resignal: FALSE
[17:29:44.664] - force: TRUE
[17:29:44.664] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:44.664] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:44.665]  - until=3
[17:29:44.665]  - relaying element #3
[17:29:44.665] result() for ClusterFuture ...
[17:29:44.665] - result already collected: FutureResult
[17:29:44.666] result() for ClusterFuture ... done
[17:29:44.666] result() for ClusterFuture ...
[17:29:44.666] - result already collected: FutureResult
[17:29:44.666] result() for ClusterFuture ... done
[17:29:44.667] result() for ClusterFuture ...
[17:29:44.667] - result already collected: FutureResult
[17:29:44.667] result() for ClusterFuture ... done
[17:29:44.668] result() for ClusterFuture ...
[17:29:44.668] - result already collected: FutureResult
[17:29:44.668] result() for ClusterFuture ... done
[17:29:44.669] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:44.669] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:44.669] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:29:44.670]  length: 1 (resolved future 3)
[17:29:44.670] receiveMessageFromWorker() for ClusterFuture ...
[17:29:44.671] - Validating connection of MultisessionFuture
[17:29:44.671] - received message: FutureResult
[17:29:44.671] - Received FutureResult
[17:29:44.672] - Erased future from FutureRegistry
[17:29:44.672] result() for ClusterFuture ...
[17:29:44.672] - result already collected: FutureResult
[17:29:44.673] result() for ClusterFuture ... done
[17:29:44.673] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:44.673] Future #4
[17:29:44.673] result() for ClusterFuture ...
[17:29:44.674] - result already collected: FutureResult
[17:29:44.674] result() for ClusterFuture ... done
[17:29:44.674] result() for ClusterFuture ...
[17:29:44.675] - result already collected: FutureResult
[17:29:44.675] result() for ClusterFuture ... done
[17:29:44.675] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:29:44.675] - nx: 4
[17:29:44.676] - relay: TRUE
[17:29:44.676] - stdout: TRUE
[17:29:44.676] - signal: TRUE
[17:29:44.676] - resignal: FALSE
[17:29:44.677] - force: TRUE
[17:29:44.677] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:44.677] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:44.678]  - until=4
[17:29:44.678]  - relaying element #4
[17:29:44.678] result() for ClusterFuture ...
[17:29:44.678] - result already collected: FutureResult
[17:29:44.679] result() for ClusterFuture ... done
[17:29:44.679] result() for ClusterFuture ...
[17:29:44.679] - result already collected: FutureResult
[17:29:44.679] result() for ClusterFuture ... done
[17:29:44.680] result() for ClusterFuture ...
[17:29:44.680] - result already collected: FutureResult
[17:29:44.680] result() for ClusterFuture ... done
[17:29:44.681] result() for ClusterFuture ...
[17:29:44.681] - result already collected: FutureResult
[17:29:44.681] result() for ClusterFuture ... done
[17:29:44.681] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:44.682] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:44.682] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:29:44.682]  length: 0 (resolved future 4)
[17:29:44.682] Relaying remaining futures
[17:29:44.683] signalConditionsASAP(NULL, pos=0) ...
[17:29:44.683] - nx: 4
[17:29:44.683] - relay: TRUE
[17:29:44.683] - stdout: TRUE
[17:29:44.684] - signal: TRUE
[17:29:44.684] - resignal: FALSE
[17:29:44.684] - force: TRUE
[17:29:44.684] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:44.685] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:29:44.685] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:44.685] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:44.686] signalConditionsASAP(NULL, pos=0) ... done
[17:29:44.686] resolve() on list ... DONE
[17:29:44.686] result() for ClusterFuture ...
[17:29:44.686] - result already collected: FutureResult
[17:29:44.687] result() for ClusterFuture ... done
[17:29:44.687] result() for ClusterFuture ...
[17:29:44.687] - result already collected: FutureResult
[17:29:44.687] result() for ClusterFuture ... done
[17:29:44.688] result() for ClusterFuture ...
[17:29:44.688] - result already collected: FutureResult
[17:29:44.688] result() for ClusterFuture ... done
[17:29:44.689] result() for ClusterFuture ...
[17:29:44.689] - result already collected: FutureResult
[17:29:44.689] result() for ClusterFuture ... done
[17:29:44.689] result() for ClusterFuture ...
[17:29:44.690] - result already collected: FutureResult
[17:29:44.690] result() for ClusterFuture ... done
[17:29:44.690] result() for ClusterFuture ...
[17:29:44.690] - result already collected: FutureResult
[17:29:44.691] result() for ClusterFuture ... done
[17:29:44.691] result() for ClusterFuture ...
[17:29:44.691] - result already collected: FutureResult
[17:29:44.691] result() for ClusterFuture ... done
[17:29:44.692] result() for ClusterFuture ...
[17:29:44.692] - result already collected: FutureResult
[17:29:44.692] result() for ClusterFuture ... done
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[17:29:44.693] getGlobalsAndPackages() ...
[17:29:44.693] Searching for globals...
[17:29:44.695] - globals found: [3] '{', 'sample', 'x'
[17:29:44.695] Searching for globals ... DONE
[17:29:44.696] Resolving globals: FALSE
[17:29:44.697] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:44.697] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:44.698] - globals: [1] 'x'
[17:29:44.698] 
[17:29:44.698] getGlobalsAndPackages() ... DONE
[17:29:44.699] run() for 'Future' ...
[17:29:44.699] - state: 'created'
[17:29:44.699] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:44.719] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:44.719] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:44.719]   - Field: 'node'
[17:29:44.720]   - Field: 'label'
[17:29:44.720]   - Field: 'local'
[17:29:44.720]   - Field: 'owner'
[17:29:44.721]   - Field: 'envir'
[17:29:44.721]   - Field: 'workers'
[17:29:44.721]   - Field: 'packages'
[17:29:44.721]   - Field: 'gc'
[17:29:44.722]   - Field: 'conditions'
[17:29:44.722]   - Field: 'persistent'
[17:29:44.722]   - Field: 'expr'
[17:29:44.723]   - Field: 'uuid'
[17:29:44.723]   - Field: 'seed'
[17:29:44.723]   - Field: 'version'
[17:29:44.723]   - Field: 'result'
[17:29:44.724]   - Field: 'asynchronous'
[17:29:44.724]   - Field: 'calls'
[17:29:44.724]   - Field: 'globals'
[17:29:44.725]   - Field: 'stdout'
[17:29:44.725]   - Field: 'earlySignal'
[17:29:44.725]   - Field: 'lazy'
[17:29:44.725]   - Field: 'state'
[17:29:44.726] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:44.726] - Launch lazy future ...
[17:29:44.727] Packages needed by the future expression (n = 0): <none>
[17:29:44.727] Packages needed by future strategies (n = 0): <none>
[17:29:44.728] {
[17:29:44.728]     {
[17:29:44.728]         {
[17:29:44.728]             ...future.startTime <- base::Sys.time()
[17:29:44.728]             {
[17:29:44.728]                 {
[17:29:44.728]                   {
[17:29:44.728]                     {
[17:29:44.728]                       {
[17:29:44.728]                         base::local({
[17:29:44.728]                           has_future <- base::requireNamespace("future", 
[17:29:44.728]                             quietly = TRUE)
[17:29:44.728]                           if (has_future) {
[17:29:44.728]                             ns <- base::getNamespace("future")
[17:29:44.728]                             version <- ns[[".package"]][["version"]]
[17:29:44.728]                             if (is.null(version)) 
[17:29:44.728]                               version <- utils::packageVersion("future")
[17:29:44.728]                           }
[17:29:44.728]                           else {
[17:29:44.728]                             version <- NULL
[17:29:44.728]                           }
[17:29:44.728]                           if (!has_future || version < "1.8.0") {
[17:29:44.728]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:44.728]                               "", base::R.version$version.string), 
[17:29:44.728]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:44.728]                                 base::R.version$platform, 8 * 
[17:29:44.728]                                   base::.Machine$sizeof.pointer), 
[17:29:44.728]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:44.728]                                 "release", "version")], collapse = " "), 
[17:29:44.728]                               hostname = base::Sys.info()[["nodename"]])
[17:29:44.728]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:44.728]                               info)
[17:29:44.728]                             info <- base::paste(info, collapse = "; ")
[17:29:44.728]                             if (!has_future) {
[17:29:44.728]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:44.728]                                 info)
[17:29:44.728]                             }
[17:29:44.728]                             else {
[17:29:44.728]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:44.728]                                 info, version)
[17:29:44.728]                             }
[17:29:44.728]                             base::stop(msg)
[17:29:44.728]                           }
[17:29:44.728]                         })
[17:29:44.728]                       }
[17:29:44.728]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:44.728]                       base::options(mc.cores = 1L)
[17:29:44.728]                     }
[17:29:44.728]                     ...future.strategy.old <- future::plan("list")
[17:29:44.728]                     options(future.plan = NULL)
[17:29:44.728]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:44.728]                     future::plan("default", .cleanup = FALSE, 
[17:29:44.728]                       .init = FALSE)
[17:29:44.728]                   }
[17:29:44.728]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[17:29:44.728]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[17:29:44.728]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[17:29:44.728]                 }
[17:29:44.728]                 ...future.workdir <- getwd()
[17:29:44.728]             }
[17:29:44.728]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:44.728]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:44.728]         }
[17:29:44.728]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:44.728]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:44.728]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:44.728]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:44.728]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:44.728]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:44.728]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:44.728]             base::names(...future.oldOptions))
[17:29:44.728]     }
[17:29:44.728]     if (FALSE) {
[17:29:44.728]     }
[17:29:44.728]     else {
[17:29:44.728]         if (TRUE) {
[17:29:44.728]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:44.728]                 open = "w")
[17:29:44.728]         }
[17:29:44.728]         else {
[17:29:44.728]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:44.728]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:44.728]         }
[17:29:44.728]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:44.728]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:44.728]             base::sink(type = "output", split = FALSE)
[17:29:44.728]             base::close(...future.stdout)
[17:29:44.728]         }, add = TRUE)
[17:29:44.728]     }
[17:29:44.728]     ...future.frame <- base::sys.nframe()
[17:29:44.728]     ...future.conditions <- base::list()
[17:29:44.728]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:44.728]     if (FALSE) {
[17:29:44.728]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:44.728]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:44.728]     }
[17:29:44.728]     ...future.result <- base::tryCatch({
[17:29:44.728]         base::withCallingHandlers({
[17:29:44.728]             ...future.value <- base::withVisible(base::local({
[17:29:44.728]                 ...future.makeSendCondition <- base::local({
[17:29:44.728]                   sendCondition <- NULL
[17:29:44.728]                   function(frame = 1L) {
[17:29:44.728]                     if (is.function(sendCondition)) 
[17:29:44.728]                       return(sendCondition)
[17:29:44.728]                     ns <- getNamespace("parallel")
[17:29:44.728]                     if (exists("sendData", mode = "function", 
[17:29:44.728]                       envir = ns)) {
[17:29:44.728]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:44.728]                         envir = ns)
[17:29:44.728]                       envir <- sys.frame(frame)
[17:29:44.728]                       master <- NULL
[17:29:44.728]                       while (!identical(envir, .GlobalEnv) && 
[17:29:44.728]                         !identical(envir, emptyenv())) {
[17:29:44.728]                         if (exists("master", mode = "list", envir = envir, 
[17:29:44.728]                           inherits = FALSE)) {
[17:29:44.728]                           master <- get("master", mode = "list", 
[17:29:44.728]                             envir = envir, inherits = FALSE)
[17:29:44.728]                           if (inherits(master, c("SOCKnode", 
[17:29:44.728]                             "SOCK0node"))) {
[17:29:44.728]                             sendCondition <<- function(cond) {
[17:29:44.728]                               data <- list(type = "VALUE", value = cond, 
[17:29:44.728]                                 success = TRUE)
[17:29:44.728]                               parallel_sendData(master, data)
[17:29:44.728]                             }
[17:29:44.728]                             return(sendCondition)
[17:29:44.728]                           }
[17:29:44.728]                         }
[17:29:44.728]                         frame <- frame + 1L
[17:29:44.728]                         envir <- sys.frame(frame)
[17:29:44.728]                       }
[17:29:44.728]                     }
[17:29:44.728]                     sendCondition <<- function(cond) NULL
[17:29:44.728]                   }
[17:29:44.728]                 })
[17:29:44.728]                 withCallingHandlers({
[17:29:44.728]                   {
[17:29:44.728]                     sample(x, size = 1L)
[17:29:44.728]                   }
[17:29:44.728]                 }, immediateCondition = function(cond) {
[17:29:44.728]                   sendCondition <- ...future.makeSendCondition()
[17:29:44.728]                   sendCondition(cond)
[17:29:44.728]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.728]                   {
[17:29:44.728]                     inherits <- base::inherits
[17:29:44.728]                     invokeRestart <- base::invokeRestart
[17:29:44.728]                     is.null <- base::is.null
[17:29:44.728]                     muffled <- FALSE
[17:29:44.728]                     if (inherits(cond, "message")) {
[17:29:44.728]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:44.728]                       if (muffled) 
[17:29:44.728]                         invokeRestart("muffleMessage")
[17:29:44.728]                     }
[17:29:44.728]                     else if (inherits(cond, "warning")) {
[17:29:44.728]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:44.728]                       if (muffled) 
[17:29:44.728]                         invokeRestart("muffleWarning")
[17:29:44.728]                     }
[17:29:44.728]                     else if (inherits(cond, "condition")) {
[17:29:44.728]                       if (!is.null(pattern)) {
[17:29:44.728]                         computeRestarts <- base::computeRestarts
[17:29:44.728]                         grepl <- base::grepl
[17:29:44.728]                         restarts <- computeRestarts(cond)
[17:29:44.728]                         for (restart in restarts) {
[17:29:44.728]                           name <- restart$name
[17:29:44.728]                           if (is.null(name)) 
[17:29:44.728]                             next
[17:29:44.728]                           if (!grepl(pattern, name)) 
[17:29:44.728]                             next
[17:29:44.728]                           invokeRestart(restart)
[17:29:44.728]                           muffled <- TRUE
[17:29:44.728]                           break
[17:29:44.728]                         }
[17:29:44.728]                       }
[17:29:44.728]                     }
[17:29:44.728]                     invisible(muffled)
[17:29:44.728]                   }
[17:29:44.728]                   muffleCondition(cond)
[17:29:44.728]                 })
[17:29:44.728]             }))
[17:29:44.728]             future::FutureResult(value = ...future.value$value, 
[17:29:44.728]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:44.728]                   ...future.rng), globalenv = if (FALSE) 
[17:29:44.728]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:44.728]                     ...future.globalenv.names))
[17:29:44.728]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:44.728]         }, condition = base::local({
[17:29:44.728]             c <- base::c
[17:29:44.728]             inherits <- base::inherits
[17:29:44.728]             invokeRestart <- base::invokeRestart
[17:29:44.728]             length <- base::length
[17:29:44.728]             list <- base::list
[17:29:44.728]             seq.int <- base::seq.int
[17:29:44.728]             signalCondition <- base::signalCondition
[17:29:44.728]             sys.calls <- base::sys.calls
[17:29:44.728]             `[[` <- base::`[[`
[17:29:44.728]             `+` <- base::`+`
[17:29:44.728]             `<<-` <- base::`<<-`
[17:29:44.728]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:44.728]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:44.728]                   3L)]
[17:29:44.728]             }
[17:29:44.728]             function(cond) {
[17:29:44.728]                 is_error <- inherits(cond, "error")
[17:29:44.728]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:44.728]                   NULL)
[17:29:44.728]                 if (is_error) {
[17:29:44.728]                   sessionInformation <- function() {
[17:29:44.728]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:44.728]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:44.728]                       search = base::search(), system = base::Sys.info())
[17:29:44.728]                   }
[17:29:44.728]                   ...future.conditions[[length(...future.conditions) + 
[17:29:44.728]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:44.728]                     cond$call), session = sessionInformation(), 
[17:29:44.728]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:44.728]                   signalCondition(cond)
[17:29:44.728]                 }
[17:29:44.728]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:44.728]                 "immediateCondition"))) {
[17:29:44.728]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:44.728]                   ...future.conditions[[length(...future.conditions) + 
[17:29:44.728]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:44.728]                   if (TRUE && !signal) {
[17:29:44.728]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.728]                     {
[17:29:44.728]                       inherits <- base::inherits
[17:29:44.728]                       invokeRestart <- base::invokeRestart
[17:29:44.728]                       is.null <- base::is.null
[17:29:44.728]                       muffled <- FALSE
[17:29:44.728]                       if (inherits(cond, "message")) {
[17:29:44.728]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:44.728]                         if (muffled) 
[17:29:44.728]                           invokeRestart("muffleMessage")
[17:29:44.728]                       }
[17:29:44.728]                       else if (inherits(cond, "warning")) {
[17:29:44.728]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:44.728]                         if (muffled) 
[17:29:44.728]                           invokeRestart("muffleWarning")
[17:29:44.728]                       }
[17:29:44.728]                       else if (inherits(cond, "condition")) {
[17:29:44.728]                         if (!is.null(pattern)) {
[17:29:44.728]                           computeRestarts <- base::computeRestarts
[17:29:44.728]                           grepl <- base::grepl
[17:29:44.728]                           restarts <- computeRestarts(cond)
[17:29:44.728]                           for (restart in restarts) {
[17:29:44.728]                             name <- restart$name
[17:29:44.728]                             if (is.null(name)) 
[17:29:44.728]                               next
[17:29:44.728]                             if (!grepl(pattern, name)) 
[17:29:44.728]                               next
[17:29:44.728]                             invokeRestart(restart)
[17:29:44.728]                             muffled <- TRUE
[17:29:44.728]                             break
[17:29:44.728]                           }
[17:29:44.728]                         }
[17:29:44.728]                       }
[17:29:44.728]                       invisible(muffled)
[17:29:44.728]                     }
[17:29:44.728]                     muffleCondition(cond, pattern = "^muffle")
[17:29:44.728]                   }
[17:29:44.728]                 }
[17:29:44.728]                 else {
[17:29:44.728]                   if (TRUE) {
[17:29:44.728]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.728]                     {
[17:29:44.728]                       inherits <- base::inherits
[17:29:44.728]                       invokeRestart <- base::invokeRestart
[17:29:44.728]                       is.null <- base::is.null
[17:29:44.728]                       muffled <- FALSE
[17:29:44.728]                       if (inherits(cond, "message")) {
[17:29:44.728]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:44.728]                         if (muffled) 
[17:29:44.728]                           invokeRestart("muffleMessage")
[17:29:44.728]                       }
[17:29:44.728]                       else if (inherits(cond, "warning")) {
[17:29:44.728]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:44.728]                         if (muffled) 
[17:29:44.728]                           invokeRestart("muffleWarning")
[17:29:44.728]                       }
[17:29:44.728]                       else if (inherits(cond, "condition")) {
[17:29:44.728]                         if (!is.null(pattern)) {
[17:29:44.728]                           computeRestarts <- base::computeRestarts
[17:29:44.728]                           grepl <- base::grepl
[17:29:44.728]                           restarts <- computeRestarts(cond)
[17:29:44.728]                           for (restart in restarts) {
[17:29:44.728]                             name <- restart$name
[17:29:44.728]                             if (is.null(name)) 
[17:29:44.728]                               next
[17:29:44.728]                             if (!grepl(pattern, name)) 
[17:29:44.728]                               next
[17:29:44.728]                             invokeRestart(restart)
[17:29:44.728]                             muffled <- TRUE
[17:29:44.728]                             break
[17:29:44.728]                           }
[17:29:44.728]                         }
[17:29:44.728]                       }
[17:29:44.728]                       invisible(muffled)
[17:29:44.728]                     }
[17:29:44.728]                     muffleCondition(cond, pattern = "^muffle")
[17:29:44.728]                   }
[17:29:44.728]                 }
[17:29:44.728]             }
[17:29:44.728]         }))
[17:29:44.728]     }, error = function(ex) {
[17:29:44.728]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:44.728]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:44.728]                 ...future.rng), started = ...future.startTime, 
[17:29:44.728]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:44.728]             version = "1.8"), class = "FutureResult")
[17:29:44.728]     }, finally = {
[17:29:44.728]         if (!identical(...future.workdir, getwd())) 
[17:29:44.728]             setwd(...future.workdir)
[17:29:44.728]         {
[17:29:44.728]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:44.728]                 ...future.oldOptions$nwarnings <- NULL
[17:29:44.728]             }
[17:29:44.728]             base::options(...future.oldOptions)
[17:29:44.728]             if (.Platform$OS.type == "windows") {
[17:29:44.728]                 old_names <- names(...future.oldEnvVars)
[17:29:44.728]                 envs <- base::Sys.getenv()
[17:29:44.728]                 names <- names(envs)
[17:29:44.728]                 common <- intersect(names, old_names)
[17:29:44.728]                 added <- setdiff(names, old_names)
[17:29:44.728]                 removed <- setdiff(old_names, names)
[17:29:44.728]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:44.728]                   envs[common]]
[17:29:44.728]                 NAMES <- toupper(changed)
[17:29:44.728]                 args <- list()
[17:29:44.728]                 for (kk in seq_along(NAMES)) {
[17:29:44.728]                   name <- changed[[kk]]
[17:29:44.728]                   NAME <- NAMES[[kk]]
[17:29:44.728]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.728]                     next
[17:29:44.728]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:44.728]                 }
[17:29:44.728]                 NAMES <- toupper(added)
[17:29:44.728]                 for (kk in seq_along(NAMES)) {
[17:29:44.728]                   name <- added[[kk]]
[17:29:44.728]                   NAME <- NAMES[[kk]]
[17:29:44.728]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.728]                     next
[17:29:44.728]                   args[[name]] <- ""
[17:29:44.728]                 }
[17:29:44.728]                 NAMES <- toupper(removed)
[17:29:44.728]                 for (kk in seq_along(NAMES)) {
[17:29:44.728]                   name <- removed[[kk]]
[17:29:44.728]                   NAME <- NAMES[[kk]]
[17:29:44.728]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.728]                     next
[17:29:44.728]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:44.728]                 }
[17:29:44.728]                 if (length(args) > 0) 
[17:29:44.728]                   base::do.call(base::Sys.setenv, args = args)
[17:29:44.728]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:44.728]             }
[17:29:44.728]             else {
[17:29:44.728]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:44.728]             }
[17:29:44.728]             {
[17:29:44.728]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:44.728]                   0L) {
[17:29:44.728]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:44.728]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:44.728]                   base::options(opts)
[17:29:44.728]                 }
[17:29:44.728]                 {
[17:29:44.728]                   {
[17:29:44.728]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:44.728]                     NULL
[17:29:44.728]                   }
[17:29:44.728]                   options(future.plan = NULL)
[17:29:44.728]                   if (is.na(NA_character_)) 
[17:29:44.728]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:44.728]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:44.728]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:44.728]                     .init = FALSE)
[17:29:44.728]                 }
[17:29:44.728]             }
[17:29:44.728]         }
[17:29:44.728]     })
[17:29:44.728]     if (TRUE) {
[17:29:44.728]         base::sink(type = "output", split = FALSE)
[17:29:44.728]         if (TRUE) {
[17:29:44.728]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:44.728]         }
[17:29:44.728]         else {
[17:29:44.728]             ...future.result["stdout"] <- base::list(NULL)
[17:29:44.728]         }
[17:29:44.728]         base::close(...future.stdout)
[17:29:44.728]         ...future.stdout <- NULL
[17:29:44.728]     }
[17:29:44.728]     ...future.result$conditions <- ...future.conditions
[17:29:44.728]     ...future.result$finished <- base::Sys.time()
[17:29:44.728]     ...future.result
[17:29:44.728] }
[17:29:44.737] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:44.737] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:44.738] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:44.738] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:44.739] MultisessionFuture started
[17:29:44.740] - Launch lazy future ... done
[17:29:44.740] run() for 'MultisessionFuture' ... done
[17:29:44.740] getGlobalsAndPackages() ...
[17:29:44.741] Searching for globals...
[17:29:44.743] - globals found: [3] '{', 'sample', 'x'
[17:29:44.743] Searching for globals ... DONE
[17:29:44.743] Resolving globals: FALSE
[17:29:44.744] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:44.745] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:44.745] - globals: [1] 'x'
[17:29:44.745] 
[17:29:44.746] getGlobalsAndPackages() ... DONE
[17:29:44.746] run() for 'Future' ...
[17:29:44.746] - state: 'created'
[17:29:44.747] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:44.767] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:44.767] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:44.767]   - Field: 'node'
[17:29:44.768]   - Field: 'label'
[17:29:44.768]   - Field: 'local'
[17:29:44.768]   - Field: 'owner'
[17:29:44.769]   - Field: 'envir'
[17:29:44.769]   - Field: 'workers'
[17:29:44.769]   - Field: 'packages'
[17:29:44.769]   - Field: 'gc'
[17:29:44.770]   - Field: 'conditions'
[17:29:44.770]   - Field: 'persistent'
[17:29:44.770]   - Field: 'expr'
[17:29:44.771]   - Field: 'uuid'
[17:29:44.771]   - Field: 'seed'
[17:29:44.771]   - Field: 'version'
[17:29:44.771]   - Field: 'result'
[17:29:44.772]   - Field: 'asynchronous'
[17:29:44.772]   - Field: 'calls'
[17:29:44.772]   - Field: 'globals'
[17:29:44.773]   - Field: 'stdout'
[17:29:44.773]   - Field: 'earlySignal'
[17:29:44.773]   - Field: 'lazy'
[17:29:44.774]   - Field: 'state'
[17:29:44.774] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:44.774] - Launch lazy future ...
[17:29:44.775] Packages needed by the future expression (n = 0): <none>
[17:29:44.775] Packages needed by future strategies (n = 0): <none>
[17:29:44.776] {
[17:29:44.776]     {
[17:29:44.776]         {
[17:29:44.776]             ...future.startTime <- base::Sys.time()
[17:29:44.776]             {
[17:29:44.776]                 {
[17:29:44.776]                   {
[17:29:44.776]                     {
[17:29:44.776]                       {
[17:29:44.776]                         base::local({
[17:29:44.776]                           has_future <- base::requireNamespace("future", 
[17:29:44.776]                             quietly = TRUE)
[17:29:44.776]                           if (has_future) {
[17:29:44.776]                             ns <- base::getNamespace("future")
[17:29:44.776]                             version <- ns[[".package"]][["version"]]
[17:29:44.776]                             if (is.null(version)) 
[17:29:44.776]                               version <- utils::packageVersion("future")
[17:29:44.776]                           }
[17:29:44.776]                           else {
[17:29:44.776]                             version <- NULL
[17:29:44.776]                           }
[17:29:44.776]                           if (!has_future || version < "1.8.0") {
[17:29:44.776]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:44.776]                               "", base::R.version$version.string), 
[17:29:44.776]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:44.776]                                 base::R.version$platform, 8 * 
[17:29:44.776]                                   base::.Machine$sizeof.pointer), 
[17:29:44.776]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:44.776]                                 "release", "version")], collapse = " "), 
[17:29:44.776]                               hostname = base::Sys.info()[["nodename"]])
[17:29:44.776]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:44.776]                               info)
[17:29:44.776]                             info <- base::paste(info, collapse = "; ")
[17:29:44.776]                             if (!has_future) {
[17:29:44.776]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:44.776]                                 info)
[17:29:44.776]                             }
[17:29:44.776]                             else {
[17:29:44.776]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:44.776]                                 info, version)
[17:29:44.776]                             }
[17:29:44.776]                             base::stop(msg)
[17:29:44.776]                           }
[17:29:44.776]                         })
[17:29:44.776]                       }
[17:29:44.776]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:44.776]                       base::options(mc.cores = 1L)
[17:29:44.776]                     }
[17:29:44.776]                     ...future.strategy.old <- future::plan("list")
[17:29:44.776]                     options(future.plan = NULL)
[17:29:44.776]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:44.776]                     future::plan("default", .cleanup = FALSE, 
[17:29:44.776]                       .init = FALSE)
[17:29:44.776]                   }
[17:29:44.776]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[17:29:44.776]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[17:29:44.776]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[17:29:44.776]                 }
[17:29:44.776]                 ...future.workdir <- getwd()
[17:29:44.776]             }
[17:29:44.776]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:44.776]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:44.776]         }
[17:29:44.776]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:44.776]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:44.776]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:44.776]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:44.776]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:44.776]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:44.776]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:44.776]             base::names(...future.oldOptions))
[17:29:44.776]     }
[17:29:44.776]     if (FALSE) {
[17:29:44.776]     }
[17:29:44.776]     else {
[17:29:44.776]         if (TRUE) {
[17:29:44.776]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:44.776]                 open = "w")
[17:29:44.776]         }
[17:29:44.776]         else {
[17:29:44.776]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:44.776]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:44.776]         }
[17:29:44.776]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:44.776]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:44.776]             base::sink(type = "output", split = FALSE)
[17:29:44.776]             base::close(...future.stdout)
[17:29:44.776]         }, add = TRUE)
[17:29:44.776]     }
[17:29:44.776]     ...future.frame <- base::sys.nframe()
[17:29:44.776]     ...future.conditions <- base::list()
[17:29:44.776]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:44.776]     if (FALSE) {
[17:29:44.776]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:44.776]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:44.776]     }
[17:29:44.776]     ...future.result <- base::tryCatch({
[17:29:44.776]         base::withCallingHandlers({
[17:29:44.776]             ...future.value <- base::withVisible(base::local({
[17:29:44.776]                 ...future.makeSendCondition <- base::local({
[17:29:44.776]                   sendCondition <- NULL
[17:29:44.776]                   function(frame = 1L) {
[17:29:44.776]                     if (is.function(sendCondition)) 
[17:29:44.776]                       return(sendCondition)
[17:29:44.776]                     ns <- getNamespace("parallel")
[17:29:44.776]                     if (exists("sendData", mode = "function", 
[17:29:44.776]                       envir = ns)) {
[17:29:44.776]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:44.776]                         envir = ns)
[17:29:44.776]                       envir <- sys.frame(frame)
[17:29:44.776]                       master <- NULL
[17:29:44.776]                       while (!identical(envir, .GlobalEnv) && 
[17:29:44.776]                         !identical(envir, emptyenv())) {
[17:29:44.776]                         if (exists("master", mode = "list", envir = envir, 
[17:29:44.776]                           inherits = FALSE)) {
[17:29:44.776]                           master <- get("master", mode = "list", 
[17:29:44.776]                             envir = envir, inherits = FALSE)
[17:29:44.776]                           if (inherits(master, c("SOCKnode", 
[17:29:44.776]                             "SOCK0node"))) {
[17:29:44.776]                             sendCondition <<- function(cond) {
[17:29:44.776]                               data <- list(type = "VALUE", value = cond, 
[17:29:44.776]                                 success = TRUE)
[17:29:44.776]                               parallel_sendData(master, data)
[17:29:44.776]                             }
[17:29:44.776]                             return(sendCondition)
[17:29:44.776]                           }
[17:29:44.776]                         }
[17:29:44.776]                         frame <- frame + 1L
[17:29:44.776]                         envir <- sys.frame(frame)
[17:29:44.776]                       }
[17:29:44.776]                     }
[17:29:44.776]                     sendCondition <<- function(cond) NULL
[17:29:44.776]                   }
[17:29:44.776]                 })
[17:29:44.776]                 withCallingHandlers({
[17:29:44.776]                   {
[17:29:44.776]                     sample(x, size = 1L)
[17:29:44.776]                   }
[17:29:44.776]                 }, immediateCondition = function(cond) {
[17:29:44.776]                   sendCondition <- ...future.makeSendCondition()
[17:29:44.776]                   sendCondition(cond)
[17:29:44.776]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.776]                   {
[17:29:44.776]                     inherits <- base::inherits
[17:29:44.776]                     invokeRestart <- base::invokeRestart
[17:29:44.776]                     is.null <- base::is.null
[17:29:44.776]                     muffled <- FALSE
[17:29:44.776]                     if (inherits(cond, "message")) {
[17:29:44.776]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:44.776]                       if (muffled) 
[17:29:44.776]                         invokeRestart("muffleMessage")
[17:29:44.776]                     }
[17:29:44.776]                     else if (inherits(cond, "warning")) {
[17:29:44.776]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:44.776]                       if (muffled) 
[17:29:44.776]                         invokeRestart("muffleWarning")
[17:29:44.776]                     }
[17:29:44.776]                     else if (inherits(cond, "condition")) {
[17:29:44.776]                       if (!is.null(pattern)) {
[17:29:44.776]                         computeRestarts <- base::computeRestarts
[17:29:44.776]                         grepl <- base::grepl
[17:29:44.776]                         restarts <- computeRestarts(cond)
[17:29:44.776]                         for (restart in restarts) {
[17:29:44.776]                           name <- restart$name
[17:29:44.776]                           if (is.null(name)) 
[17:29:44.776]                             next
[17:29:44.776]                           if (!grepl(pattern, name)) 
[17:29:44.776]                             next
[17:29:44.776]                           invokeRestart(restart)
[17:29:44.776]                           muffled <- TRUE
[17:29:44.776]                           break
[17:29:44.776]                         }
[17:29:44.776]                       }
[17:29:44.776]                     }
[17:29:44.776]                     invisible(muffled)
[17:29:44.776]                   }
[17:29:44.776]                   muffleCondition(cond)
[17:29:44.776]                 })
[17:29:44.776]             }))
[17:29:44.776]             future::FutureResult(value = ...future.value$value, 
[17:29:44.776]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:44.776]                   ...future.rng), globalenv = if (FALSE) 
[17:29:44.776]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:44.776]                     ...future.globalenv.names))
[17:29:44.776]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:44.776]         }, condition = base::local({
[17:29:44.776]             c <- base::c
[17:29:44.776]             inherits <- base::inherits
[17:29:44.776]             invokeRestart <- base::invokeRestart
[17:29:44.776]             length <- base::length
[17:29:44.776]             list <- base::list
[17:29:44.776]             seq.int <- base::seq.int
[17:29:44.776]             signalCondition <- base::signalCondition
[17:29:44.776]             sys.calls <- base::sys.calls
[17:29:44.776]             `[[` <- base::`[[`
[17:29:44.776]             `+` <- base::`+`
[17:29:44.776]             `<<-` <- base::`<<-`
[17:29:44.776]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:44.776]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:44.776]                   3L)]
[17:29:44.776]             }
[17:29:44.776]             function(cond) {
[17:29:44.776]                 is_error <- inherits(cond, "error")
[17:29:44.776]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:44.776]                   NULL)
[17:29:44.776]                 if (is_error) {
[17:29:44.776]                   sessionInformation <- function() {
[17:29:44.776]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:44.776]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:44.776]                       search = base::search(), system = base::Sys.info())
[17:29:44.776]                   }
[17:29:44.776]                   ...future.conditions[[length(...future.conditions) + 
[17:29:44.776]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:44.776]                     cond$call), session = sessionInformation(), 
[17:29:44.776]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:44.776]                   signalCondition(cond)
[17:29:44.776]                 }
[17:29:44.776]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:44.776]                 "immediateCondition"))) {
[17:29:44.776]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:44.776]                   ...future.conditions[[length(...future.conditions) + 
[17:29:44.776]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:44.776]                   if (TRUE && !signal) {
[17:29:44.776]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.776]                     {
[17:29:44.776]                       inherits <- base::inherits
[17:29:44.776]                       invokeRestart <- base::invokeRestart
[17:29:44.776]                       is.null <- base::is.null
[17:29:44.776]                       muffled <- FALSE
[17:29:44.776]                       if (inherits(cond, "message")) {
[17:29:44.776]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:44.776]                         if (muffled) 
[17:29:44.776]                           invokeRestart("muffleMessage")
[17:29:44.776]                       }
[17:29:44.776]                       else if (inherits(cond, "warning")) {
[17:29:44.776]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:44.776]                         if (muffled) 
[17:29:44.776]                           invokeRestart("muffleWarning")
[17:29:44.776]                       }
[17:29:44.776]                       else if (inherits(cond, "condition")) {
[17:29:44.776]                         if (!is.null(pattern)) {
[17:29:44.776]                           computeRestarts <- base::computeRestarts
[17:29:44.776]                           grepl <- base::grepl
[17:29:44.776]                           restarts <- computeRestarts(cond)
[17:29:44.776]                           for (restart in restarts) {
[17:29:44.776]                             name <- restart$name
[17:29:44.776]                             if (is.null(name)) 
[17:29:44.776]                               next
[17:29:44.776]                             if (!grepl(pattern, name)) 
[17:29:44.776]                               next
[17:29:44.776]                             invokeRestart(restart)
[17:29:44.776]                             muffled <- TRUE
[17:29:44.776]                             break
[17:29:44.776]                           }
[17:29:44.776]                         }
[17:29:44.776]                       }
[17:29:44.776]                       invisible(muffled)
[17:29:44.776]                     }
[17:29:44.776]                     muffleCondition(cond, pattern = "^muffle")
[17:29:44.776]                   }
[17:29:44.776]                 }
[17:29:44.776]                 else {
[17:29:44.776]                   if (TRUE) {
[17:29:44.776]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.776]                     {
[17:29:44.776]                       inherits <- base::inherits
[17:29:44.776]                       invokeRestart <- base::invokeRestart
[17:29:44.776]                       is.null <- base::is.null
[17:29:44.776]                       muffled <- FALSE
[17:29:44.776]                       if (inherits(cond, "message")) {
[17:29:44.776]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:44.776]                         if (muffled) 
[17:29:44.776]                           invokeRestart("muffleMessage")
[17:29:44.776]                       }
[17:29:44.776]                       else if (inherits(cond, "warning")) {
[17:29:44.776]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:44.776]                         if (muffled) 
[17:29:44.776]                           invokeRestart("muffleWarning")
[17:29:44.776]                       }
[17:29:44.776]                       else if (inherits(cond, "condition")) {
[17:29:44.776]                         if (!is.null(pattern)) {
[17:29:44.776]                           computeRestarts <- base::computeRestarts
[17:29:44.776]                           grepl <- base::grepl
[17:29:44.776]                           restarts <- computeRestarts(cond)
[17:29:44.776]                           for (restart in restarts) {
[17:29:44.776]                             name <- restart$name
[17:29:44.776]                             if (is.null(name)) 
[17:29:44.776]                               next
[17:29:44.776]                             if (!grepl(pattern, name)) 
[17:29:44.776]                               next
[17:29:44.776]                             invokeRestart(restart)
[17:29:44.776]                             muffled <- TRUE
[17:29:44.776]                             break
[17:29:44.776]                           }
[17:29:44.776]                         }
[17:29:44.776]                       }
[17:29:44.776]                       invisible(muffled)
[17:29:44.776]                     }
[17:29:44.776]                     muffleCondition(cond, pattern = "^muffle")
[17:29:44.776]                   }
[17:29:44.776]                 }
[17:29:44.776]             }
[17:29:44.776]         }))
[17:29:44.776]     }, error = function(ex) {
[17:29:44.776]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:44.776]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:44.776]                 ...future.rng), started = ...future.startTime, 
[17:29:44.776]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:44.776]             version = "1.8"), class = "FutureResult")
[17:29:44.776]     }, finally = {
[17:29:44.776]         if (!identical(...future.workdir, getwd())) 
[17:29:44.776]             setwd(...future.workdir)
[17:29:44.776]         {
[17:29:44.776]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:44.776]                 ...future.oldOptions$nwarnings <- NULL
[17:29:44.776]             }
[17:29:44.776]             base::options(...future.oldOptions)
[17:29:44.776]             if (.Platform$OS.type == "windows") {
[17:29:44.776]                 old_names <- names(...future.oldEnvVars)
[17:29:44.776]                 envs <- base::Sys.getenv()
[17:29:44.776]                 names <- names(envs)
[17:29:44.776]                 common <- intersect(names, old_names)
[17:29:44.776]                 added <- setdiff(names, old_names)
[17:29:44.776]                 removed <- setdiff(old_names, names)
[17:29:44.776]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:44.776]                   envs[common]]
[17:29:44.776]                 NAMES <- toupper(changed)
[17:29:44.776]                 args <- list()
[17:29:44.776]                 for (kk in seq_along(NAMES)) {
[17:29:44.776]                   name <- changed[[kk]]
[17:29:44.776]                   NAME <- NAMES[[kk]]
[17:29:44.776]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.776]                     next
[17:29:44.776]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:44.776]                 }
[17:29:44.776]                 NAMES <- toupper(added)
[17:29:44.776]                 for (kk in seq_along(NAMES)) {
[17:29:44.776]                   name <- added[[kk]]
[17:29:44.776]                   NAME <- NAMES[[kk]]
[17:29:44.776]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.776]                     next
[17:29:44.776]                   args[[name]] <- ""
[17:29:44.776]                 }
[17:29:44.776]                 NAMES <- toupper(removed)
[17:29:44.776]                 for (kk in seq_along(NAMES)) {
[17:29:44.776]                   name <- removed[[kk]]
[17:29:44.776]                   NAME <- NAMES[[kk]]
[17:29:44.776]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.776]                     next
[17:29:44.776]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:44.776]                 }
[17:29:44.776]                 if (length(args) > 0) 
[17:29:44.776]                   base::do.call(base::Sys.setenv, args = args)
[17:29:44.776]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:44.776]             }
[17:29:44.776]             else {
[17:29:44.776]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:44.776]             }
[17:29:44.776]             {
[17:29:44.776]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:44.776]                   0L) {
[17:29:44.776]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:44.776]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:44.776]                   base::options(opts)
[17:29:44.776]                 }
[17:29:44.776]                 {
[17:29:44.776]                   {
[17:29:44.776]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:44.776]                     NULL
[17:29:44.776]                   }
[17:29:44.776]                   options(future.plan = NULL)
[17:29:44.776]                   if (is.na(NA_character_)) 
[17:29:44.776]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:44.776]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:44.776]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:44.776]                     .init = FALSE)
[17:29:44.776]                 }
[17:29:44.776]             }
[17:29:44.776]         }
[17:29:44.776]     })
[17:29:44.776]     if (TRUE) {
[17:29:44.776]         base::sink(type = "output", split = FALSE)
[17:29:44.776]         if (TRUE) {
[17:29:44.776]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:44.776]         }
[17:29:44.776]         else {
[17:29:44.776]             ...future.result["stdout"] <- base::list(NULL)
[17:29:44.776]         }
[17:29:44.776]         base::close(...future.stdout)
[17:29:44.776]         ...future.stdout <- NULL
[17:29:44.776]     }
[17:29:44.776]     ...future.result$conditions <- ...future.conditions
[17:29:44.776]     ...future.result$finished <- base::Sys.time()
[17:29:44.776]     ...future.result
[17:29:44.776] }
[17:29:44.786] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:44.786] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:44.787] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:44.787] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:44.788] MultisessionFuture started
[17:29:44.788] - Launch lazy future ... done
[17:29:44.789] run() for 'MultisessionFuture' ... done
[17:29:44.789] getGlobalsAndPackages() ...
[17:29:44.790] Searching for globals...
[17:29:44.792] - globals found: [3] '{', 'sample', 'x'
[17:29:44.792] Searching for globals ... DONE
[17:29:44.792] Resolving globals: FALSE
[17:29:44.793] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:44.794] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:44.794] - globals: [1] 'x'
[17:29:44.795] 
[17:29:44.795] getGlobalsAndPackages() ... DONE
[17:29:44.796] run() for 'Future' ...
[17:29:44.796] - state: 'created'
[17:29:44.796] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:44.817] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:44.818] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:44.818]   - Field: 'node'
[17:29:44.818]   - Field: 'label'
[17:29:44.819]   - Field: 'local'
[17:29:44.819]   - Field: 'owner'
[17:29:44.819]   - Field: 'envir'
[17:29:44.820]   - Field: 'workers'
[17:29:44.820]   - Field: 'packages'
[17:29:44.821]   - Field: 'gc'
[17:29:44.821]   - Field: 'conditions'
[17:29:44.821]   - Field: 'persistent'
[17:29:44.822]   - Field: 'expr'
[17:29:44.822]   - Field: 'uuid'
[17:29:44.822]   - Field: 'seed'
[17:29:44.822]   - Field: 'version'
[17:29:44.823]   - Field: 'result'
[17:29:44.823]   - Field: 'asynchronous'
[17:29:44.823]   - Field: 'calls'
[17:29:44.824]   - Field: 'globals'
[17:29:44.824]   - Field: 'stdout'
[17:29:44.824]   - Field: 'earlySignal'
[17:29:44.825]   - Field: 'lazy'
[17:29:44.825]   - Field: 'state'
[17:29:44.825] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:44.826] - Launch lazy future ...
[17:29:44.826] Packages needed by the future expression (n = 0): <none>
[17:29:44.827] Packages needed by future strategies (n = 0): <none>
[17:29:44.828] {
[17:29:44.828]     {
[17:29:44.828]         {
[17:29:44.828]             ...future.startTime <- base::Sys.time()
[17:29:44.828]             {
[17:29:44.828]                 {
[17:29:44.828]                   {
[17:29:44.828]                     {
[17:29:44.828]                       {
[17:29:44.828]                         base::local({
[17:29:44.828]                           has_future <- base::requireNamespace("future", 
[17:29:44.828]                             quietly = TRUE)
[17:29:44.828]                           if (has_future) {
[17:29:44.828]                             ns <- base::getNamespace("future")
[17:29:44.828]                             version <- ns[[".package"]][["version"]]
[17:29:44.828]                             if (is.null(version)) 
[17:29:44.828]                               version <- utils::packageVersion("future")
[17:29:44.828]                           }
[17:29:44.828]                           else {
[17:29:44.828]                             version <- NULL
[17:29:44.828]                           }
[17:29:44.828]                           if (!has_future || version < "1.8.0") {
[17:29:44.828]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:44.828]                               "", base::R.version$version.string), 
[17:29:44.828]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:44.828]                                 base::R.version$platform, 8 * 
[17:29:44.828]                                   base::.Machine$sizeof.pointer), 
[17:29:44.828]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:44.828]                                 "release", "version")], collapse = " "), 
[17:29:44.828]                               hostname = base::Sys.info()[["nodename"]])
[17:29:44.828]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:44.828]                               info)
[17:29:44.828]                             info <- base::paste(info, collapse = "; ")
[17:29:44.828]                             if (!has_future) {
[17:29:44.828]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:44.828]                                 info)
[17:29:44.828]                             }
[17:29:44.828]                             else {
[17:29:44.828]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:44.828]                                 info, version)
[17:29:44.828]                             }
[17:29:44.828]                             base::stop(msg)
[17:29:44.828]                           }
[17:29:44.828]                         })
[17:29:44.828]                       }
[17:29:44.828]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:44.828]                       base::options(mc.cores = 1L)
[17:29:44.828]                     }
[17:29:44.828]                     ...future.strategy.old <- future::plan("list")
[17:29:44.828]                     options(future.plan = NULL)
[17:29:44.828]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:44.828]                     future::plan("default", .cleanup = FALSE, 
[17:29:44.828]                       .init = FALSE)
[17:29:44.828]                   }
[17:29:44.828]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[17:29:44.828]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[17:29:44.828]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[17:29:44.828]                 }
[17:29:44.828]                 ...future.workdir <- getwd()
[17:29:44.828]             }
[17:29:44.828]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:44.828]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:44.828]         }
[17:29:44.828]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:44.828]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:44.828]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:44.828]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:44.828]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:44.828]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:44.828]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:44.828]             base::names(...future.oldOptions))
[17:29:44.828]     }
[17:29:44.828]     if (FALSE) {
[17:29:44.828]     }
[17:29:44.828]     else {
[17:29:44.828]         if (TRUE) {
[17:29:44.828]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:44.828]                 open = "w")
[17:29:44.828]         }
[17:29:44.828]         else {
[17:29:44.828]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:44.828]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:44.828]         }
[17:29:44.828]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:44.828]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:44.828]             base::sink(type = "output", split = FALSE)
[17:29:44.828]             base::close(...future.stdout)
[17:29:44.828]         }, add = TRUE)
[17:29:44.828]     }
[17:29:44.828]     ...future.frame <- base::sys.nframe()
[17:29:44.828]     ...future.conditions <- base::list()
[17:29:44.828]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:44.828]     if (FALSE) {
[17:29:44.828]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:44.828]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:44.828]     }
[17:29:44.828]     ...future.result <- base::tryCatch({
[17:29:44.828]         base::withCallingHandlers({
[17:29:44.828]             ...future.value <- base::withVisible(base::local({
[17:29:44.828]                 ...future.makeSendCondition <- base::local({
[17:29:44.828]                   sendCondition <- NULL
[17:29:44.828]                   function(frame = 1L) {
[17:29:44.828]                     if (is.function(sendCondition)) 
[17:29:44.828]                       return(sendCondition)
[17:29:44.828]                     ns <- getNamespace("parallel")
[17:29:44.828]                     if (exists("sendData", mode = "function", 
[17:29:44.828]                       envir = ns)) {
[17:29:44.828]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:44.828]                         envir = ns)
[17:29:44.828]                       envir <- sys.frame(frame)
[17:29:44.828]                       master <- NULL
[17:29:44.828]                       while (!identical(envir, .GlobalEnv) && 
[17:29:44.828]                         !identical(envir, emptyenv())) {
[17:29:44.828]                         if (exists("master", mode = "list", envir = envir, 
[17:29:44.828]                           inherits = FALSE)) {
[17:29:44.828]                           master <- get("master", mode = "list", 
[17:29:44.828]                             envir = envir, inherits = FALSE)
[17:29:44.828]                           if (inherits(master, c("SOCKnode", 
[17:29:44.828]                             "SOCK0node"))) {
[17:29:44.828]                             sendCondition <<- function(cond) {
[17:29:44.828]                               data <- list(type = "VALUE", value = cond, 
[17:29:44.828]                                 success = TRUE)
[17:29:44.828]                               parallel_sendData(master, data)
[17:29:44.828]                             }
[17:29:44.828]                             return(sendCondition)
[17:29:44.828]                           }
[17:29:44.828]                         }
[17:29:44.828]                         frame <- frame + 1L
[17:29:44.828]                         envir <- sys.frame(frame)
[17:29:44.828]                       }
[17:29:44.828]                     }
[17:29:44.828]                     sendCondition <<- function(cond) NULL
[17:29:44.828]                   }
[17:29:44.828]                 })
[17:29:44.828]                 withCallingHandlers({
[17:29:44.828]                   {
[17:29:44.828]                     sample(x, size = 1L)
[17:29:44.828]                   }
[17:29:44.828]                 }, immediateCondition = function(cond) {
[17:29:44.828]                   sendCondition <- ...future.makeSendCondition()
[17:29:44.828]                   sendCondition(cond)
[17:29:44.828]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.828]                   {
[17:29:44.828]                     inherits <- base::inherits
[17:29:44.828]                     invokeRestart <- base::invokeRestart
[17:29:44.828]                     is.null <- base::is.null
[17:29:44.828]                     muffled <- FALSE
[17:29:44.828]                     if (inherits(cond, "message")) {
[17:29:44.828]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:44.828]                       if (muffled) 
[17:29:44.828]                         invokeRestart("muffleMessage")
[17:29:44.828]                     }
[17:29:44.828]                     else if (inherits(cond, "warning")) {
[17:29:44.828]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:44.828]                       if (muffled) 
[17:29:44.828]                         invokeRestart("muffleWarning")
[17:29:44.828]                     }
[17:29:44.828]                     else if (inherits(cond, "condition")) {
[17:29:44.828]                       if (!is.null(pattern)) {
[17:29:44.828]                         computeRestarts <- base::computeRestarts
[17:29:44.828]                         grepl <- base::grepl
[17:29:44.828]                         restarts <- computeRestarts(cond)
[17:29:44.828]                         for (restart in restarts) {
[17:29:44.828]                           name <- restart$name
[17:29:44.828]                           if (is.null(name)) 
[17:29:44.828]                             next
[17:29:44.828]                           if (!grepl(pattern, name)) 
[17:29:44.828]                             next
[17:29:44.828]                           invokeRestart(restart)
[17:29:44.828]                           muffled <- TRUE
[17:29:44.828]                           break
[17:29:44.828]                         }
[17:29:44.828]                       }
[17:29:44.828]                     }
[17:29:44.828]                     invisible(muffled)
[17:29:44.828]                   }
[17:29:44.828]                   muffleCondition(cond)
[17:29:44.828]                 })
[17:29:44.828]             }))
[17:29:44.828]             future::FutureResult(value = ...future.value$value, 
[17:29:44.828]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:44.828]                   ...future.rng), globalenv = if (FALSE) 
[17:29:44.828]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:44.828]                     ...future.globalenv.names))
[17:29:44.828]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:44.828]         }, condition = base::local({
[17:29:44.828]             c <- base::c
[17:29:44.828]             inherits <- base::inherits
[17:29:44.828]             invokeRestart <- base::invokeRestart
[17:29:44.828]             length <- base::length
[17:29:44.828]             list <- base::list
[17:29:44.828]             seq.int <- base::seq.int
[17:29:44.828]             signalCondition <- base::signalCondition
[17:29:44.828]             sys.calls <- base::sys.calls
[17:29:44.828]             `[[` <- base::`[[`
[17:29:44.828]             `+` <- base::`+`
[17:29:44.828]             `<<-` <- base::`<<-`
[17:29:44.828]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:44.828]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:44.828]                   3L)]
[17:29:44.828]             }
[17:29:44.828]             function(cond) {
[17:29:44.828]                 is_error <- inherits(cond, "error")
[17:29:44.828]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:44.828]                   NULL)
[17:29:44.828]                 if (is_error) {
[17:29:44.828]                   sessionInformation <- function() {
[17:29:44.828]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:44.828]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:44.828]                       search = base::search(), system = base::Sys.info())
[17:29:44.828]                   }
[17:29:44.828]                   ...future.conditions[[length(...future.conditions) + 
[17:29:44.828]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:44.828]                     cond$call), session = sessionInformation(), 
[17:29:44.828]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:44.828]                   signalCondition(cond)
[17:29:44.828]                 }
[17:29:44.828]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:44.828]                 "immediateCondition"))) {
[17:29:44.828]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:44.828]                   ...future.conditions[[length(...future.conditions) + 
[17:29:44.828]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:44.828]                   if (TRUE && !signal) {
[17:29:44.828]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.828]                     {
[17:29:44.828]                       inherits <- base::inherits
[17:29:44.828]                       invokeRestart <- base::invokeRestart
[17:29:44.828]                       is.null <- base::is.null
[17:29:44.828]                       muffled <- FALSE
[17:29:44.828]                       if (inherits(cond, "message")) {
[17:29:44.828]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:44.828]                         if (muffled) 
[17:29:44.828]                           invokeRestart("muffleMessage")
[17:29:44.828]                       }
[17:29:44.828]                       else if (inherits(cond, "warning")) {
[17:29:44.828]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:44.828]                         if (muffled) 
[17:29:44.828]                           invokeRestart("muffleWarning")
[17:29:44.828]                       }
[17:29:44.828]                       else if (inherits(cond, "condition")) {
[17:29:44.828]                         if (!is.null(pattern)) {
[17:29:44.828]                           computeRestarts <- base::computeRestarts
[17:29:44.828]                           grepl <- base::grepl
[17:29:44.828]                           restarts <- computeRestarts(cond)
[17:29:44.828]                           for (restart in restarts) {
[17:29:44.828]                             name <- restart$name
[17:29:44.828]                             if (is.null(name)) 
[17:29:44.828]                               next
[17:29:44.828]                             if (!grepl(pattern, name)) 
[17:29:44.828]                               next
[17:29:44.828]                             invokeRestart(restart)
[17:29:44.828]                             muffled <- TRUE
[17:29:44.828]                             break
[17:29:44.828]                           }
[17:29:44.828]                         }
[17:29:44.828]                       }
[17:29:44.828]                       invisible(muffled)
[17:29:44.828]                     }
[17:29:44.828]                     muffleCondition(cond, pattern = "^muffle")
[17:29:44.828]                   }
[17:29:44.828]                 }
[17:29:44.828]                 else {
[17:29:44.828]                   if (TRUE) {
[17:29:44.828]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.828]                     {
[17:29:44.828]                       inherits <- base::inherits
[17:29:44.828]                       invokeRestart <- base::invokeRestart
[17:29:44.828]                       is.null <- base::is.null
[17:29:44.828]                       muffled <- FALSE
[17:29:44.828]                       if (inherits(cond, "message")) {
[17:29:44.828]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:44.828]                         if (muffled) 
[17:29:44.828]                           invokeRestart("muffleMessage")
[17:29:44.828]                       }
[17:29:44.828]                       else if (inherits(cond, "warning")) {
[17:29:44.828]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:44.828]                         if (muffled) 
[17:29:44.828]                           invokeRestart("muffleWarning")
[17:29:44.828]                       }
[17:29:44.828]                       else if (inherits(cond, "condition")) {
[17:29:44.828]                         if (!is.null(pattern)) {
[17:29:44.828]                           computeRestarts <- base::computeRestarts
[17:29:44.828]                           grepl <- base::grepl
[17:29:44.828]                           restarts <- computeRestarts(cond)
[17:29:44.828]                           for (restart in restarts) {
[17:29:44.828]                             name <- restart$name
[17:29:44.828]                             if (is.null(name)) 
[17:29:44.828]                               next
[17:29:44.828]                             if (!grepl(pattern, name)) 
[17:29:44.828]                               next
[17:29:44.828]                             invokeRestart(restart)
[17:29:44.828]                             muffled <- TRUE
[17:29:44.828]                             break
[17:29:44.828]                           }
[17:29:44.828]                         }
[17:29:44.828]                       }
[17:29:44.828]                       invisible(muffled)
[17:29:44.828]                     }
[17:29:44.828]                     muffleCondition(cond, pattern = "^muffle")
[17:29:44.828]                   }
[17:29:44.828]                 }
[17:29:44.828]             }
[17:29:44.828]         }))
[17:29:44.828]     }, error = function(ex) {
[17:29:44.828]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:44.828]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:44.828]                 ...future.rng), started = ...future.startTime, 
[17:29:44.828]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:44.828]             version = "1.8"), class = "FutureResult")
[17:29:44.828]     }, finally = {
[17:29:44.828]         if (!identical(...future.workdir, getwd())) 
[17:29:44.828]             setwd(...future.workdir)
[17:29:44.828]         {
[17:29:44.828]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:44.828]                 ...future.oldOptions$nwarnings <- NULL
[17:29:44.828]             }
[17:29:44.828]             base::options(...future.oldOptions)
[17:29:44.828]             if (.Platform$OS.type == "windows") {
[17:29:44.828]                 old_names <- names(...future.oldEnvVars)
[17:29:44.828]                 envs <- base::Sys.getenv()
[17:29:44.828]                 names <- names(envs)
[17:29:44.828]                 common <- intersect(names, old_names)
[17:29:44.828]                 added <- setdiff(names, old_names)
[17:29:44.828]                 removed <- setdiff(old_names, names)
[17:29:44.828]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:44.828]                   envs[common]]
[17:29:44.828]                 NAMES <- toupper(changed)
[17:29:44.828]                 args <- list()
[17:29:44.828]                 for (kk in seq_along(NAMES)) {
[17:29:44.828]                   name <- changed[[kk]]
[17:29:44.828]                   NAME <- NAMES[[kk]]
[17:29:44.828]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.828]                     next
[17:29:44.828]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:44.828]                 }
[17:29:44.828]                 NAMES <- toupper(added)
[17:29:44.828]                 for (kk in seq_along(NAMES)) {
[17:29:44.828]                   name <- added[[kk]]
[17:29:44.828]                   NAME <- NAMES[[kk]]
[17:29:44.828]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.828]                     next
[17:29:44.828]                   args[[name]] <- ""
[17:29:44.828]                 }
[17:29:44.828]                 NAMES <- toupper(removed)
[17:29:44.828]                 for (kk in seq_along(NAMES)) {
[17:29:44.828]                   name <- removed[[kk]]
[17:29:44.828]                   NAME <- NAMES[[kk]]
[17:29:44.828]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.828]                     next
[17:29:44.828]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:44.828]                 }
[17:29:44.828]                 if (length(args) > 0) 
[17:29:44.828]                   base::do.call(base::Sys.setenv, args = args)
[17:29:44.828]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:44.828]             }
[17:29:44.828]             else {
[17:29:44.828]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:44.828]             }
[17:29:44.828]             {
[17:29:44.828]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:44.828]                   0L) {
[17:29:44.828]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:44.828]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:44.828]                   base::options(opts)
[17:29:44.828]                 }
[17:29:44.828]                 {
[17:29:44.828]                   {
[17:29:44.828]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:44.828]                     NULL
[17:29:44.828]                   }
[17:29:44.828]                   options(future.plan = NULL)
[17:29:44.828]                   if (is.na(NA_character_)) 
[17:29:44.828]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:44.828]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:44.828]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:44.828]                     .init = FALSE)
[17:29:44.828]                 }
[17:29:44.828]             }
[17:29:44.828]         }
[17:29:44.828]     })
[17:29:44.828]     if (TRUE) {
[17:29:44.828]         base::sink(type = "output", split = FALSE)
[17:29:44.828]         if (TRUE) {
[17:29:44.828]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:44.828]         }
[17:29:44.828]         else {
[17:29:44.828]             ...future.result["stdout"] <- base::list(NULL)
[17:29:44.828]         }
[17:29:44.828]         base::close(...future.stdout)
[17:29:44.828]         ...future.stdout <- NULL
[17:29:44.828]     }
[17:29:44.828]     ...future.result$conditions <- ...future.conditions
[17:29:44.828]     ...future.result$finished <- base::Sys.time()
[17:29:44.828]     ...future.result
[17:29:44.828] }
[17:29:44.836] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:44.848] receiveMessageFromWorker() for ClusterFuture ...
[17:29:44.848] - Validating connection of MultisessionFuture
[17:29:44.849] - received message: FutureResult
[17:29:44.849] - Received FutureResult
[17:29:44.849] - Erased future from FutureRegistry
[17:29:44.849] result() for ClusterFuture ...
[17:29:44.850] - result already collected: FutureResult
[17:29:44.850] result() for ClusterFuture ... done
[17:29:44.850] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:44.851] result() for ClusterFuture ...
[17:29:44.851] - result already collected: FutureResult
[17:29:44.851] result() for ClusterFuture ... done
[17:29:44.851] result() for ClusterFuture ...
[17:29:44.851] - result already collected: FutureResult
[17:29:44.852] result() for ClusterFuture ... done
[17:29:44.853] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:44.853] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:44.856] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:44.856] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:44.857] MultisessionFuture started
[17:29:44.857] - Launch lazy future ... done
[17:29:44.857] run() for 'MultisessionFuture' ... done
[17:29:44.858] getGlobalsAndPackages() ...
[17:29:44.858] Searching for globals...
[17:29:44.859] - globals found: [3] '{', 'sample', 'x'
[17:29:44.859] Searching for globals ... DONE
[17:29:44.859] Resolving globals: FALSE
[17:29:44.860] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:44.861] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:44.861] - globals: [1] 'x'
[17:29:44.861] 
[17:29:44.861] getGlobalsAndPackages() ... DONE
[17:29:44.861] run() for 'Future' ...
[17:29:44.862] - state: 'created'
[17:29:44.862] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:44.880] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:44.880] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:44.880]   - Field: 'node'
[17:29:44.881]   - Field: 'label'
[17:29:44.881]   - Field: 'local'
[17:29:44.881]   - Field: 'owner'
[17:29:44.881]   - Field: 'envir'
[17:29:44.882]   - Field: 'workers'
[17:29:44.882]   - Field: 'packages'
[17:29:44.882]   - Field: 'gc'
[17:29:44.883]   - Field: 'conditions'
[17:29:44.883]   - Field: 'persistent'
[17:29:44.883]   - Field: 'expr'
[17:29:44.883]   - Field: 'uuid'
[17:29:44.884]   - Field: 'seed'
[17:29:44.884]   - Field: 'version'
[17:29:44.884]   - Field: 'result'
[17:29:44.884]   - Field: 'asynchronous'
[17:29:44.885]   - Field: 'calls'
[17:29:44.885]   - Field: 'globals'
[17:29:44.885]   - Field: 'stdout'
[17:29:44.886]   - Field: 'earlySignal'
[17:29:44.886]   - Field: 'lazy'
[17:29:44.886]   - Field: 'state'
[17:29:44.886] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:44.887] - Launch lazy future ...
[17:29:44.887] Packages needed by the future expression (n = 0): <none>
[17:29:44.887] Packages needed by future strategies (n = 0): <none>
[17:29:44.888] {
[17:29:44.888]     {
[17:29:44.888]         {
[17:29:44.888]             ...future.startTime <- base::Sys.time()
[17:29:44.888]             {
[17:29:44.888]                 {
[17:29:44.888]                   {
[17:29:44.888]                     {
[17:29:44.888]                       {
[17:29:44.888]                         base::local({
[17:29:44.888]                           has_future <- base::requireNamespace("future", 
[17:29:44.888]                             quietly = TRUE)
[17:29:44.888]                           if (has_future) {
[17:29:44.888]                             ns <- base::getNamespace("future")
[17:29:44.888]                             version <- ns[[".package"]][["version"]]
[17:29:44.888]                             if (is.null(version)) 
[17:29:44.888]                               version <- utils::packageVersion("future")
[17:29:44.888]                           }
[17:29:44.888]                           else {
[17:29:44.888]                             version <- NULL
[17:29:44.888]                           }
[17:29:44.888]                           if (!has_future || version < "1.8.0") {
[17:29:44.888]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:44.888]                               "", base::R.version$version.string), 
[17:29:44.888]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:44.888]                                 base::R.version$platform, 8 * 
[17:29:44.888]                                   base::.Machine$sizeof.pointer), 
[17:29:44.888]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:44.888]                                 "release", "version")], collapse = " "), 
[17:29:44.888]                               hostname = base::Sys.info()[["nodename"]])
[17:29:44.888]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:44.888]                               info)
[17:29:44.888]                             info <- base::paste(info, collapse = "; ")
[17:29:44.888]                             if (!has_future) {
[17:29:44.888]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:44.888]                                 info)
[17:29:44.888]                             }
[17:29:44.888]                             else {
[17:29:44.888]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:44.888]                                 info, version)
[17:29:44.888]                             }
[17:29:44.888]                             base::stop(msg)
[17:29:44.888]                           }
[17:29:44.888]                         })
[17:29:44.888]                       }
[17:29:44.888]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:44.888]                       base::options(mc.cores = 1L)
[17:29:44.888]                     }
[17:29:44.888]                     ...future.strategy.old <- future::plan("list")
[17:29:44.888]                     options(future.plan = NULL)
[17:29:44.888]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:44.888]                     future::plan("default", .cleanup = FALSE, 
[17:29:44.888]                       .init = FALSE)
[17:29:44.888]                   }
[17:29:44.888]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[17:29:44.888]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[17:29:44.888]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[17:29:44.888]                 }
[17:29:44.888]                 ...future.workdir <- getwd()
[17:29:44.888]             }
[17:29:44.888]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:44.888]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:44.888]         }
[17:29:44.888]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:44.888]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:44.888]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:44.888]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:44.888]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:44.888]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:44.888]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:44.888]             base::names(...future.oldOptions))
[17:29:44.888]     }
[17:29:44.888]     if (FALSE) {
[17:29:44.888]     }
[17:29:44.888]     else {
[17:29:44.888]         if (TRUE) {
[17:29:44.888]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:44.888]                 open = "w")
[17:29:44.888]         }
[17:29:44.888]         else {
[17:29:44.888]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:44.888]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:44.888]         }
[17:29:44.888]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:44.888]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:44.888]             base::sink(type = "output", split = FALSE)
[17:29:44.888]             base::close(...future.stdout)
[17:29:44.888]         }, add = TRUE)
[17:29:44.888]     }
[17:29:44.888]     ...future.frame <- base::sys.nframe()
[17:29:44.888]     ...future.conditions <- base::list()
[17:29:44.888]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:44.888]     if (FALSE) {
[17:29:44.888]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:44.888]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:44.888]     }
[17:29:44.888]     ...future.result <- base::tryCatch({
[17:29:44.888]         base::withCallingHandlers({
[17:29:44.888]             ...future.value <- base::withVisible(base::local({
[17:29:44.888]                 ...future.makeSendCondition <- base::local({
[17:29:44.888]                   sendCondition <- NULL
[17:29:44.888]                   function(frame = 1L) {
[17:29:44.888]                     if (is.function(sendCondition)) 
[17:29:44.888]                       return(sendCondition)
[17:29:44.888]                     ns <- getNamespace("parallel")
[17:29:44.888]                     if (exists("sendData", mode = "function", 
[17:29:44.888]                       envir = ns)) {
[17:29:44.888]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:44.888]                         envir = ns)
[17:29:44.888]                       envir <- sys.frame(frame)
[17:29:44.888]                       master <- NULL
[17:29:44.888]                       while (!identical(envir, .GlobalEnv) && 
[17:29:44.888]                         !identical(envir, emptyenv())) {
[17:29:44.888]                         if (exists("master", mode = "list", envir = envir, 
[17:29:44.888]                           inherits = FALSE)) {
[17:29:44.888]                           master <- get("master", mode = "list", 
[17:29:44.888]                             envir = envir, inherits = FALSE)
[17:29:44.888]                           if (inherits(master, c("SOCKnode", 
[17:29:44.888]                             "SOCK0node"))) {
[17:29:44.888]                             sendCondition <<- function(cond) {
[17:29:44.888]                               data <- list(type = "VALUE", value = cond, 
[17:29:44.888]                                 success = TRUE)
[17:29:44.888]                               parallel_sendData(master, data)
[17:29:44.888]                             }
[17:29:44.888]                             return(sendCondition)
[17:29:44.888]                           }
[17:29:44.888]                         }
[17:29:44.888]                         frame <- frame + 1L
[17:29:44.888]                         envir <- sys.frame(frame)
[17:29:44.888]                       }
[17:29:44.888]                     }
[17:29:44.888]                     sendCondition <<- function(cond) NULL
[17:29:44.888]                   }
[17:29:44.888]                 })
[17:29:44.888]                 withCallingHandlers({
[17:29:44.888]                   {
[17:29:44.888]                     sample(x, size = 1L)
[17:29:44.888]                   }
[17:29:44.888]                 }, immediateCondition = function(cond) {
[17:29:44.888]                   sendCondition <- ...future.makeSendCondition()
[17:29:44.888]                   sendCondition(cond)
[17:29:44.888]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.888]                   {
[17:29:44.888]                     inherits <- base::inherits
[17:29:44.888]                     invokeRestart <- base::invokeRestart
[17:29:44.888]                     is.null <- base::is.null
[17:29:44.888]                     muffled <- FALSE
[17:29:44.888]                     if (inherits(cond, "message")) {
[17:29:44.888]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:44.888]                       if (muffled) 
[17:29:44.888]                         invokeRestart("muffleMessage")
[17:29:44.888]                     }
[17:29:44.888]                     else if (inherits(cond, "warning")) {
[17:29:44.888]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:44.888]                       if (muffled) 
[17:29:44.888]                         invokeRestart("muffleWarning")
[17:29:44.888]                     }
[17:29:44.888]                     else if (inherits(cond, "condition")) {
[17:29:44.888]                       if (!is.null(pattern)) {
[17:29:44.888]                         computeRestarts <- base::computeRestarts
[17:29:44.888]                         grepl <- base::grepl
[17:29:44.888]                         restarts <- computeRestarts(cond)
[17:29:44.888]                         for (restart in restarts) {
[17:29:44.888]                           name <- restart$name
[17:29:44.888]                           if (is.null(name)) 
[17:29:44.888]                             next
[17:29:44.888]                           if (!grepl(pattern, name)) 
[17:29:44.888]                             next
[17:29:44.888]                           invokeRestart(restart)
[17:29:44.888]                           muffled <- TRUE
[17:29:44.888]                           break
[17:29:44.888]                         }
[17:29:44.888]                       }
[17:29:44.888]                     }
[17:29:44.888]                     invisible(muffled)
[17:29:44.888]                   }
[17:29:44.888]                   muffleCondition(cond)
[17:29:44.888]                 })
[17:29:44.888]             }))
[17:29:44.888]             future::FutureResult(value = ...future.value$value, 
[17:29:44.888]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:44.888]                   ...future.rng), globalenv = if (FALSE) 
[17:29:44.888]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:44.888]                     ...future.globalenv.names))
[17:29:44.888]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:44.888]         }, condition = base::local({
[17:29:44.888]             c <- base::c
[17:29:44.888]             inherits <- base::inherits
[17:29:44.888]             invokeRestart <- base::invokeRestart
[17:29:44.888]             length <- base::length
[17:29:44.888]             list <- base::list
[17:29:44.888]             seq.int <- base::seq.int
[17:29:44.888]             signalCondition <- base::signalCondition
[17:29:44.888]             sys.calls <- base::sys.calls
[17:29:44.888]             `[[` <- base::`[[`
[17:29:44.888]             `+` <- base::`+`
[17:29:44.888]             `<<-` <- base::`<<-`
[17:29:44.888]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:44.888]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:44.888]                   3L)]
[17:29:44.888]             }
[17:29:44.888]             function(cond) {
[17:29:44.888]                 is_error <- inherits(cond, "error")
[17:29:44.888]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:44.888]                   NULL)
[17:29:44.888]                 if (is_error) {
[17:29:44.888]                   sessionInformation <- function() {
[17:29:44.888]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:44.888]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:44.888]                       search = base::search(), system = base::Sys.info())
[17:29:44.888]                   }
[17:29:44.888]                   ...future.conditions[[length(...future.conditions) + 
[17:29:44.888]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:44.888]                     cond$call), session = sessionInformation(), 
[17:29:44.888]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:44.888]                   signalCondition(cond)
[17:29:44.888]                 }
[17:29:44.888]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:44.888]                 "immediateCondition"))) {
[17:29:44.888]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:44.888]                   ...future.conditions[[length(...future.conditions) + 
[17:29:44.888]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:44.888]                   if (TRUE && !signal) {
[17:29:44.888]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.888]                     {
[17:29:44.888]                       inherits <- base::inherits
[17:29:44.888]                       invokeRestart <- base::invokeRestart
[17:29:44.888]                       is.null <- base::is.null
[17:29:44.888]                       muffled <- FALSE
[17:29:44.888]                       if (inherits(cond, "message")) {
[17:29:44.888]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:44.888]                         if (muffled) 
[17:29:44.888]                           invokeRestart("muffleMessage")
[17:29:44.888]                       }
[17:29:44.888]                       else if (inherits(cond, "warning")) {
[17:29:44.888]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:44.888]                         if (muffled) 
[17:29:44.888]                           invokeRestart("muffleWarning")
[17:29:44.888]                       }
[17:29:44.888]                       else if (inherits(cond, "condition")) {
[17:29:44.888]                         if (!is.null(pattern)) {
[17:29:44.888]                           computeRestarts <- base::computeRestarts
[17:29:44.888]                           grepl <- base::grepl
[17:29:44.888]                           restarts <- computeRestarts(cond)
[17:29:44.888]                           for (restart in restarts) {
[17:29:44.888]                             name <- restart$name
[17:29:44.888]                             if (is.null(name)) 
[17:29:44.888]                               next
[17:29:44.888]                             if (!grepl(pattern, name)) 
[17:29:44.888]                               next
[17:29:44.888]                             invokeRestart(restart)
[17:29:44.888]                             muffled <- TRUE
[17:29:44.888]                             break
[17:29:44.888]                           }
[17:29:44.888]                         }
[17:29:44.888]                       }
[17:29:44.888]                       invisible(muffled)
[17:29:44.888]                     }
[17:29:44.888]                     muffleCondition(cond, pattern = "^muffle")
[17:29:44.888]                   }
[17:29:44.888]                 }
[17:29:44.888]                 else {
[17:29:44.888]                   if (TRUE) {
[17:29:44.888]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.888]                     {
[17:29:44.888]                       inherits <- base::inherits
[17:29:44.888]                       invokeRestart <- base::invokeRestart
[17:29:44.888]                       is.null <- base::is.null
[17:29:44.888]                       muffled <- FALSE
[17:29:44.888]                       if (inherits(cond, "message")) {
[17:29:44.888]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:44.888]                         if (muffled) 
[17:29:44.888]                           invokeRestart("muffleMessage")
[17:29:44.888]                       }
[17:29:44.888]                       else if (inherits(cond, "warning")) {
[17:29:44.888]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:44.888]                         if (muffled) 
[17:29:44.888]                           invokeRestart("muffleWarning")
[17:29:44.888]                       }
[17:29:44.888]                       else if (inherits(cond, "condition")) {
[17:29:44.888]                         if (!is.null(pattern)) {
[17:29:44.888]                           computeRestarts <- base::computeRestarts
[17:29:44.888]                           grepl <- base::grepl
[17:29:44.888]                           restarts <- computeRestarts(cond)
[17:29:44.888]                           for (restart in restarts) {
[17:29:44.888]                             name <- restart$name
[17:29:44.888]                             if (is.null(name)) 
[17:29:44.888]                               next
[17:29:44.888]                             if (!grepl(pattern, name)) 
[17:29:44.888]                               next
[17:29:44.888]                             invokeRestart(restart)
[17:29:44.888]                             muffled <- TRUE
[17:29:44.888]                             break
[17:29:44.888]                           }
[17:29:44.888]                         }
[17:29:44.888]                       }
[17:29:44.888]                       invisible(muffled)
[17:29:44.888]                     }
[17:29:44.888]                     muffleCondition(cond, pattern = "^muffle")
[17:29:44.888]                   }
[17:29:44.888]                 }
[17:29:44.888]             }
[17:29:44.888]         }))
[17:29:44.888]     }, error = function(ex) {
[17:29:44.888]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:44.888]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:44.888]                 ...future.rng), started = ...future.startTime, 
[17:29:44.888]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:44.888]             version = "1.8"), class = "FutureResult")
[17:29:44.888]     }, finally = {
[17:29:44.888]         if (!identical(...future.workdir, getwd())) 
[17:29:44.888]             setwd(...future.workdir)
[17:29:44.888]         {
[17:29:44.888]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:44.888]                 ...future.oldOptions$nwarnings <- NULL
[17:29:44.888]             }
[17:29:44.888]             base::options(...future.oldOptions)
[17:29:44.888]             if (.Platform$OS.type == "windows") {
[17:29:44.888]                 old_names <- names(...future.oldEnvVars)
[17:29:44.888]                 envs <- base::Sys.getenv()
[17:29:44.888]                 names <- names(envs)
[17:29:44.888]                 common <- intersect(names, old_names)
[17:29:44.888]                 added <- setdiff(names, old_names)
[17:29:44.888]                 removed <- setdiff(old_names, names)
[17:29:44.888]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:44.888]                   envs[common]]
[17:29:44.888]                 NAMES <- toupper(changed)
[17:29:44.888]                 args <- list()
[17:29:44.888]                 for (kk in seq_along(NAMES)) {
[17:29:44.888]                   name <- changed[[kk]]
[17:29:44.888]                   NAME <- NAMES[[kk]]
[17:29:44.888]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.888]                     next
[17:29:44.888]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:44.888]                 }
[17:29:44.888]                 NAMES <- toupper(added)
[17:29:44.888]                 for (kk in seq_along(NAMES)) {
[17:29:44.888]                   name <- added[[kk]]
[17:29:44.888]                   NAME <- NAMES[[kk]]
[17:29:44.888]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.888]                     next
[17:29:44.888]                   args[[name]] <- ""
[17:29:44.888]                 }
[17:29:44.888]                 NAMES <- toupper(removed)
[17:29:44.888]                 for (kk in seq_along(NAMES)) {
[17:29:44.888]                   name <- removed[[kk]]
[17:29:44.888]                   NAME <- NAMES[[kk]]
[17:29:44.888]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.888]                     next
[17:29:44.888]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:44.888]                 }
[17:29:44.888]                 if (length(args) > 0) 
[17:29:44.888]                   base::do.call(base::Sys.setenv, args = args)
[17:29:44.888]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:44.888]             }
[17:29:44.888]             else {
[17:29:44.888]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:44.888]             }
[17:29:44.888]             {
[17:29:44.888]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:44.888]                   0L) {
[17:29:44.888]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:44.888]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:44.888]                   base::options(opts)
[17:29:44.888]                 }
[17:29:44.888]                 {
[17:29:44.888]                   {
[17:29:44.888]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:44.888]                     NULL
[17:29:44.888]                   }
[17:29:44.888]                   options(future.plan = NULL)
[17:29:44.888]                   if (is.na(NA_character_)) 
[17:29:44.888]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:44.888]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:44.888]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:44.888]                     .init = FALSE)
[17:29:44.888]                 }
[17:29:44.888]             }
[17:29:44.888]         }
[17:29:44.888]     })
[17:29:44.888]     if (TRUE) {
[17:29:44.888]         base::sink(type = "output", split = FALSE)
[17:29:44.888]         if (TRUE) {
[17:29:44.888]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:44.888]         }
[17:29:44.888]         else {
[17:29:44.888]             ...future.result["stdout"] <- base::list(NULL)
[17:29:44.888]         }
[17:29:44.888]         base::close(...future.stdout)
[17:29:44.888]         ...future.stdout <- NULL
[17:29:44.888]     }
[17:29:44.888]     ...future.result$conditions <- ...future.conditions
[17:29:44.888]     ...future.result$finished <- base::Sys.time()
[17:29:44.888]     ...future.result
[17:29:44.888] }
[17:29:44.897] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:44.910] receiveMessageFromWorker() for ClusterFuture ...
[17:29:44.910] - Validating connection of MultisessionFuture
[17:29:44.911] - received message: FutureResult
[17:29:44.911] - Received FutureResult
[17:29:44.912] - Erased future from FutureRegistry
[17:29:44.912] result() for ClusterFuture ...
[17:29:44.912] - result already collected: FutureResult
[17:29:44.912] result() for ClusterFuture ... done
[17:29:44.912] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:44.913] result() for ClusterFuture ...
[17:29:44.913] - result already collected: FutureResult
[17:29:44.913] result() for ClusterFuture ... done
[17:29:44.913] result() for ClusterFuture ...
[17:29:44.914] - result already collected: FutureResult
[17:29:44.914] result() for ClusterFuture ... done
[17:29:44.915] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:44.915] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:44.916] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:44.916] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:44.917] MultisessionFuture started
[17:29:44.918] - Launch lazy future ... done
[17:29:44.918] run() for 'MultisessionFuture' ... done
[17:29:44.918] resolve() on list ...
[17:29:44.918]  recursive: 0
[17:29:44.919]  length: 4
[17:29:44.919] 
[17:29:44.919] Future #1
[17:29:44.919] result() for ClusterFuture ...
[17:29:44.919] - result already collected: FutureResult
[17:29:44.920] result() for ClusterFuture ... done
[17:29:44.920] result() for ClusterFuture ...
[17:29:44.920] - result already collected: FutureResult
[17:29:44.920] result() for ClusterFuture ... done
[17:29:44.921] signalConditionsASAP(MultisessionFuture, pos=1) ...
[17:29:44.921] - nx: 4
[17:29:44.921] - relay: TRUE
[17:29:44.921] - stdout: TRUE
[17:29:44.921] - signal: TRUE
[17:29:44.922] - resignal: FALSE
[17:29:44.922] - force: TRUE
[17:29:44.922] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:44.922] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:44.923]  - until=1
[17:29:44.923]  - relaying element #1
[17:29:44.923] result() for ClusterFuture ...
[17:29:44.923] - result already collected: FutureResult
[17:29:44.923] result() for ClusterFuture ... done
[17:29:44.924] result() for ClusterFuture ...
[17:29:44.924] - result already collected: FutureResult
[17:29:44.924] result() for ClusterFuture ... done
[17:29:44.924] result() for ClusterFuture ...
[17:29:44.925] - result already collected: FutureResult
[17:29:44.925] result() for ClusterFuture ... done
[17:29:44.925] result() for ClusterFuture ...
[17:29:44.925] - result already collected: FutureResult
[17:29:44.926] result() for ClusterFuture ... done
[17:29:44.926] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:44.926] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:44.926] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[17:29:44.927]  length: 3 (resolved future 1)
[17:29:44.927] Future #2
[17:29:44.927] result() for ClusterFuture ...
[17:29:44.927] - result already collected: FutureResult
[17:29:44.927] result() for ClusterFuture ... done
[17:29:44.928] result() for ClusterFuture ...
[17:29:44.928] - result already collected: FutureResult
[17:29:44.928] result() for ClusterFuture ... done
[17:29:44.928] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:29:44.929] - nx: 4
[17:29:44.929] - relay: TRUE
[17:29:44.929] - stdout: TRUE
[17:29:44.929] - signal: TRUE
[17:29:44.929] - resignal: FALSE
[17:29:44.930] - force: TRUE
[17:29:44.930] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:44.930] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:44.930]  - until=2
[17:29:44.931]  - relaying element #2
[17:29:44.931] result() for ClusterFuture ...
[17:29:44.931] - result already collected: FutureResult
[17:29:44.931] result() for ClusterFuture ... done
[17:29:44.931] result() for ClusterFuture ...
[17:29:44.932] - result already collected: FutureResult
[17:29:44.932] result() for ClusterFuture ... done
[17:29:44.932] result() for ClusterFuture ...
[17:29:44.932] - result already collected: FutureResult
[17:29:44.933] result() for ClusterFuture ... done
[17:29:44.933] result() for ClusterFuture ...
[17:29:44.933] - result already collected: FutureResult
[17:29:44.933] result() for ClusterFuture ... done
[17:29:44.933] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:44.934] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:44.934] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:29:44.934]  length: 2 (resolved future 2)
[17:29:44.935] receiveMessageFromWorker() for ClusterFuture ...
[17:29:44.935] - Validating connection of MultisessionFuture
[17:29:44.935] - received message: FutureResult
[17:29:44.936] - Received FutureResult
[17:29:44.936] - Erased future from FutureRegistry
[17:29:44.936] result() for ClusterFuture ...
[17:29:44.936] - result already collected: FutureResult
[17:29:44.937] result() for ClusterFuture ... done
[17:29:44.937] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:44.937] Future #3
[17:29:44.937] result() for ClusterFuture ...
[17:29:44.938] - result already collected: FutureResult
[17:29:44.938] result() for ClusterFuture ... done
[17:29:44.938] result() for ClusterFuture ...
[17:29:44.938] - result already collected: FutureResult
[17:29:44.938] result() for ClusterFuture ... done
[17:29:44.939] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:29:44.939] - nx: 4
[17:29:44.939] - relay: TRUE
[17:29:44.939] - stdout: TRUE
[17:29:44.940] - signal: TRUE
[17:29:44.940] - resignal: FALSE
[17:29:44.940] - force: TRUE
[17:29:44.940] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:44.940] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:44.941]  - until=3
[17:29:44.941]  - relaying element #3
[17:29:44.941] result() for ClusterFuture ...
[17:29:44.941] - result already collected: FutureResult
[17:29:44.941] result() for ClusterFuture ... done
[17:29:44.942] result() for ClusterFuture ...
[17:29:44.942] - result already collected: FutureResult
[17:29:44.942] result() for ClusterFuture ... done
[17:29:44.942] result() for ClusterFuture ...
[17:29:44.943] - result already collected: FutureResult
[17:29:44.943] result() for ClusterFuture ... done
[17:29:44.943] result() for ClusterFuture ...
[17:29:44.943] - result already collected: FutureResult
[17:29:44.943] result() for ClusterFuture ... done
[17:29:44.944] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:44.944] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:44.944] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:29:44.944]  length: 1 (resolved future 3)
[17:29:44.945] receiveMessageFromWorker() for ClusterFuture ...
[17:29:44.945] - Validating connection of MultisessionFuture
[17:29:44.946] - received message: FutureResult
[17:29:44.946] - Received FutureResult
[17:29:44.946] - Erased future from FutureRegistry
[17:29:44.946] result() for ClusterFuture ...
[17:29:44.947] - result already collected: FutureResult
[17:29:44.947] result() for ClusterFuture ... done
[17:29:44.947] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:44.947] Future #4
[17:29:44.947] result() for ClusterFuture ...
[17:29:44.948] - result already collected: FutureResult
[17:29:44.948] result() for ClusterFuture ... done
[17:29:44.948] result() for ClusterFuture ...
[17:29:44.948] - result already collected: FutureResult
[17:29:44.948] result() for ClusterFuture ... done
[17:29:44.949] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:29:44.949] - nx: 4
[17:29:44.949] - relay: TRUE
[17:29:44.949] - stdout: TRUE
[17:29:44.950] - signal: TRUE
[17:29:44.950] - resignal: FALSE
[17:29:44.950] - force: TRUE
[17:29:44.950] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:44.950] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:44.951]  - until=4
[17:29:44.951]  - relaying element #4
[17:29:44.951] result() for ClusterFuture ...
[17:29:44.951] - result already collected: FutureResult
[17:29:44.952] result() for ClusterFuture ... done
[17:29:44.952] result() for ClusterFuture ...
[17:29:44.952] - result already collected: FutureResult
[17:29:44.952] result() for ClusterFuture ... done
[17:29:44.953] result() for ClusterFuture ...
[17:29:44.953] - result already collected: FutureResult
[17:29:44.953] result() for ClusterFuture ... done
[17:29:44.953] result() for ClusterFuture ...
[17:29:44.954] - result already collected: FutureResult
[17:29:44.954] result() for ClusterFuture ... done
[17:29:44.954] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:44.954] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:44.954] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:29:44.955]  length: 0 (resolved future 4)
[17:29:44.955] Relaying remaining futures
[17:29:44.955] signalConditionsASAP(NULL, pos=0) ...
[17:29:44.955] - nx: 4
[17:29:44.956] - relay: TRUE
[17:29:44.956] - stdout: TRUE
[17:29:44.956] - signal: TRUE
[17:29:44.956] - resignal: FALSE
[17:29:44.957] - force: TRUE
[17:29:44.957] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:44.957] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:29:44.957] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:44.957] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:44.957] signalConditionsASAP(NULL, pos=0) ... done
[17:29:44.958] resolve() on list ... DONE
[17:29:44.958] result() for ClusterFuture ...
[17:29:44.958] - result already collected: FutureResult
[17:29:44.958] result() for ClusterFuture ... done
[17:29:44.958] result() for ClusterFuture ...
[17:29:44.958] - result already collected: FutureResult
[17:29:44.959] result() for ClusterFuture ... done
[17:29:44.959] result() for ClusterFuture ...
[17:29:44.959] - result already collected: FutureResult
[17:29:44.959] result() for ClusterFuture ... done
[17:29:44.959] result() for ClusterFuture ...
[17:29:44.959] - result already collected: FutureResult
[17:29:44.959] result() for ClusterFuture ... done
[17:29:44.960] result() for ClusterFuture ...
[17:29:44.960] - result already collected: FutureResult
[17:29:44.960] result() for ClusterFuture ... done
[17:29:44.960] result() for ClusterFuture ...
[17:29:44.960] - result already collected: FutureResult
[17:29:44.960] result() for ClusterFuture ... done
[17:29:44.961] result() for ClusterFuture ...
[17:29:44.961] - result already collected: FutureResult
[17:29:44.961] result() for ClusterFuture ... done
[17:29:44.961] result() for ClusterFuture ...
[17:29:44.961] - result already collected: FutureResult
[17:29:44.961] result() for ClusterFuture ... done
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[17:29:44.962] getGlobalsAndPackages() ...
[17:29:44.962] Searching for globals...
[17:29:44.963] - globals found: [3] '{', 'sample', 'x'
[17:29:44.964] Searching for globals ... DONE
[17:29:44.964] Resolving globals: FALSE
[17:29:44.965] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:44.965] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:44.965] - globals: [1] 'x'
[17:29:44.965] 
[17:29:44.966] getGlobalsAndPackages() ... DONE
[17:29:44.966] run() for 'Future' ...
[17:29:44.966] - state: 'created'
[17:29:44.966] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:44.982] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:44.982] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:44.982]   - Field: 'node'
[17:29:44.982]   - Field: 'label'
[17:29:44.982]   - Field: 'local'
[17:29:44.983]   - Field: 'owner'
[17:29:44.983]   - Field: 'envir'
[17:29:44.983]   - Field: 'workers'
[17:29:44.983]   - Field: 'packages'
[17:29:44.983]   - Field: 'gc'
[17:29:44.984]   - Field: 'conditions'
[17:29:44.984]   - Field: 'persistent'
[17:29:44.984]   - Field: 'expr'
[17:29:44.984]   - Field: 'uuid'
[17:29:44.984]   - Field: 'seed'
[17:29:44.984]   - Field: 'version'
[17:29:44.985]   - Field: 'result'
[17:29:44.985]   - Field: 'asynchronous'
[17:29:44.985]   - Field: 'calls'
[17:29:44.985]   - Field: 'globals'
[17:29:44.985]   - Field: 'stdout'
[17:29:44.985]   - Field: 'earlySignal'
[17:29:44.986]   - Field: 'lazy'
[17:29:44.986]   - Field: 'state'
[17:29:44.986] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:44.986] - Launch lazy future ...
[17:29:44.987] Packages needed by the future expression (n = 0): <none>
[17:29:44.987] Packages needed by future strategies (n = 0): <none>
[17:29:44.987] {
[17:29:44.987]     {
[17:29:44.987]         {
[17:29:44.987]             ...future.startTime <- base::Sys.time()
[17:29:44.987]             {
[17:29:44.987]                 {
[17:29:44.987]                   {
[17:29:44.987]                     {
[17:29:44.987]                       base::local({
[17:29:44.987]                         has_future <- base::requireNamespace("future", 
[17:29:44.987]                           quietly = TRUE)
[17:29:44.987]                         if (has_future) {
[17:29:44.987]                           ns <- base::getNamespace("future")
[17:29:44.987]                           version <- ns[[".package"]][["version"]]
[17:29:44.987]                           if (is.null(version)) 
[17:29:44.987]                             version <- utils::packageVersion("future")
[17:29:44.987]                         }
[17:29:44.987]                         else {
[17:29:44.987]                           version <- NULL
[17:29:44.987]                         }
[17:29:44.987]                         if (!has_future || version < "1.8.0") {
[17:29:44.987]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:44.987]                             "", base::R.version$version.string), 
[17:29:44.987]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:44.987]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:44.987]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:44.987]                               "release", "version")], collapse = " "), 
[17:29:44.987]                             hostname = base::Sys.info()[["nodename"]])
[17:29:44.987]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:44.987]                             info)
[17:29:44.987]                           info <- base::paste(info, collapse = "; ")
[17:29:44.987]                           if (!has_future) {
[17:29:44.987]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:44.987]                               info)
[17:29:44.987]                           }
[17:29:44.987]                           else {
[17:29:44.987]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:44.987]                               info, version)
[17:29:44.987]                           }
[17:29:44.987]                           base::stop(msg)
[17:29:44.987]                         }
[17:29:44.987]                       })
[17:29:44.987]                     }
[17:29:44.987]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:44.987]                     base::options(mc.cores = 1L)
[17:29:44.987]                   }
[17:29:44.987]                   ...future.strategy.old <- future::plan("list")
[17:29:44.987]                   options(future.plan = NULL)
[17:29:44.987]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:44.987]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:44.987]                 }
[17:29:44.987]                 ...future.workdir <- getwd()
[17:29:44.987]             }
[17:29:44.987]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:44.987]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:44.987]         }
[17:29:44.987]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:44.987]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:44.987]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:44.987]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:44.987]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:44.987]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:44.987]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:44.987]             base::names(...future.oldOptions))
[17:29:44.987]     }
[17:29:44.987]     if (FALSE) {
[17:29:44.987]     }
[17:29:44.987]     else {
[17:29:44.987]         if (TRUE) {
[17:29:44.987]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:44.987]                 open = "w")
[17:29:44.987]         }
[17:29:44.987]         else {
[17:29:44.987]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:44.987]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:44.987]         }
[17:29:44.987]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:44.987]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:44.987]             base::sink(type = "output", split = FALSE)
[17:29:44.987]             base::close(...future.stdout)
[17:29:44.987]         }, add = TRUE)
[17:29:44.987]     }
[17:29:44.987]     ...future.frame <- base::sys.nframe()
[17:29:44.987]     ...future.conditions <- base::list()
[17:29:44.987]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:44.987]     if (FALSE) {
[17:29:44.987]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:44.987]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:44.987]     }
[17:29:44.987]     ...future.result <- base::tryCatch({
[17:29:44.987]         base::withCallingHandlers({
[17:29:44.987]             ...future.value <- base::withVisible(base::local({
[17:29:44.987]                 ...future.makeSendCondition <- base::local({
[17:29:44.987]                   sendCondition <- NULL
[17:29:44.987]                   function(frame = 1L) {
[17:29:44.987]                     if (is.function(sendCondition)) 
[17:29:44.987]                       return(sendCondition)
[17:29:44.987]                     ns <- getNamespace("parallel")
[17:29:44.987]                     if (exists("sendData", mode = "function", 
[17:29:44.987]                       envir = ns)) {
[17:29:44.987]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:44.987]                         envir = ns)
[17:29:44.987]                       envir <- sys.frame(frame)
[17:29:44.987]                       master <- NULL
[17:29:44.987]                       while (!identical(envir, .GlobalEnv) && 
[17:29:44.987]                         !identical(envir, emptyenv())) {
[17:29:44.987]                         if (exists("master", mode = "list", envir = envir, 
[17:29:44.987]                           inherits = FALSE)) {
[17:29:44.987]                           master <- get("master", mode = "list", 
[17:29:44.987]                             envir = envir, inherits = FALSE)
[17:29:44.987]                           if (inherits(master, c("SOCKnode", 
[17:29:44.987]                             "SOCK0node"))) {
[17:29:44.987]                             sendCondition <<- function(cond) {
[17:29:44.987]                               data <- list(type = "VALUE", value = cond, 
[17:29:44.987]                                 success = TRUE)
[17:29:44.987]                               parallel_sendData(master, data)
[17:29:44.987]                             }
[17:29:44.987]                             return(sendCondition)
[17:29:44.987]                           }
[17:29:44.987]                         }
[17:29:44.987]                         frame <- frame + 1L
[17:29:44.987]                         envir <- sys.frame(frame)
[17:29:44.987]                       }
[17:29:44.987]                     }
[17:29:44.987]                     sendCondition <<- function(cond) NULL
[17:29:44.987]                   }
[17:29:44.987]                 })
[17:29:44.987]                 withCallingHandlers({
[17:29:44.987]                   {
[17:29:44.987]                     sample(x, size = 1L)
[17:29:44.987]                   }
[17:29:44.987]                 }, immediateCondition = function(cond) {
[17:29:44.987]                   sendCondition <- ...future.makeSendCondition()
[17:29:44.987]                   sendCondition(cond)
[17:29:44.987]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.987]                   {
[17:29:44.987]                     inherits <- base::inherits
[17:29:44.987]                     invokeRestart <- base::invokeRestart
[17:29:44.987]                     is.null <- base::is.null
[17:29:44.987]                     muffled <- FALSE
[17:29:44.987]                     if (inherits(cond, "message")) {
[17:29:44.987]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:44.987]                       if (muffled) 
[17:29:44.987]                         invokeRestart("muffleMessage")
[17:29:44.987]                     }
[17:29:44.987]                     else if (inherits(cond, "warning")) {
[17:29:44.987]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:44.987]                       if (muffled) 
[17:29:44.987]                         invokeRestart("muffleWarning")
[17:29:44.987]                     }
[17:29:44.987]                     else if (inherits(cond, "condition")) {
[17:29:44.987]                       if (!is.null(pattern)) {
[17:29:44.987]                         computeRestarts <- base::computeRestarts
[17:29:44.987]                         grepl <- base::grepl
[17:29:44.987]                         restarts <- computeRestarts(cond)
[17:29:44.987]                         for (restart in restarts) {
[17:29:44.987]                           name <- restart$name
[17:29:44.987]                           if (is.null(name)) 
[17:29:44.987]                             next
[17:29:44.987]                           if (!grepl(pattern, name)) 
[17:29:44.987]                             next
[17:29:44.987]                           invokeRestart(restart)
[17:29:44.987]                           muffled <- TRUE
[17:29:44.987]                           break
[17:29:44.987]                         }
[17:29:44.987]                       }
[17:29:44.987]                     }
[17:29:44.987]                     invisible(muffled)
[17:29:44.987]                   }
[17:29:44.987]                   muffleCondition(cond)
[17:29:44.987]                 })
[17:29:44.987]             }))
[17:29:44.987]             future::FutureResult(value = ...future.value$value, 
[17:29:44.987]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:44.987]                   ...future.rng), globalenv = if (FALSE) 
[17:29:44.987]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:44.987]                     ...future.globalenv.names))
[17:29:44.987]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:44.987]         }, condition = base::local({
[17:29:44.987]             c <- base::c
[17:29:44.987]             inherits <- base::inherits
[17:29:44.987]             invokeRestart <- base::invokeRestart
[17:29:44.987]             length <- base::length
[17:29:44.987]             list <- base::list
[17:29:44.987]             seq.int <- base::seq.int
[17:29:44.987]             signalCondition <- base::signalCondition
[17:29:44.987]             sys.calls <- base::sys.calls
[17:29:44.987]             `[[` <- base::`[[`
[17:29:44.987]             `+` <- base::`+`
[17:29:44.987]             `<<-` <- base::`<<-`
[17:29:44.987]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:44.987]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:44.987]                   3L)]
[17:29:44.987]             }
[17:29:44.987]             function(cond) {
[17:29:44.987]                 is_error <- inherits(cond, "error")
[17:29:44.987]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:44.987]                   NULL)
[17:29:44.987]                 if (is_error) {
[17:29:44.987]                   sessionInformation <- function() {
[17:29:44.987]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:44.987]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:44.987]                       search = base::search(), system = base::Sys.info())
[17:29:44.987]                   }
[17:29:44.987]                   ...future.conditions[[length(...future.conditions) + 
[17:29:44.987]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:44.987]                     cond$call), session = sessionInformation(), 
[17:29:44.987]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:44.987]                   signalCondition(cond)
[17:29:44.987]                 }
[17:29:44.987]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:44.987]                 "immediateCondition"))) {
[17:29:44.987]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:44.987]                   ...future.conditions[[length(...future.conditions) + 
[17:29:44.987]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:44.987]                   if (TRUE && !signal) {
[17:29:44.987]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.987]                     {
[17:29:44.987]                       inherits <- base::inherits
[17:29:44.987]                       invokeRestart <- base::invokeRestart
[17:29:44.987]                       is.null <- base::is.null
[17:29:44.987]                       muffled <- FALSE
[17:29:44.987]                       if (inherits(cond, "message")) {
[17:29:44.987]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:44.987]                         if (muffled) 
[17:29:44.987]                           invokeRestart("muffleMessage")
[17:29:44.987]                       }
[17:29:44.987]                       else if (inherits(cond, "warning")) {
[17:29:44.987]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:44.987]                         if (muffled) 
[17:29:44.987]                           invokeRestart("muffleWarning")
[17:29:44.987]                       }
[17:29:44.987]                       else if (inherits(cond, "condition")) {
[17:29:44.987]                         if (!is.null(pattern)) {
[17:29:44.987]                           computeRestarts <- base::computeRestarts
[17:29:44.987]                           grepl <- base::grepl
[17:29:44.987]                           restarts <- computeRestarts(cond)
[17:29:44.987]                           for (restart in restarts) {
[17:29:44.987]                             name <- restart$name
[17:29:44.987]                             if (is.null(name)) 
[17:29:44.987]                               next
[17:29:44.987]                             if (!grepl(pattern, name)) 
[17:29:44.987]                               next
[17:29:44.987]                             invokeRestart(restart)
[17:29:44.987]                             muffled <- TRUE
[17:29:44.987]                             break
[17:29:44.987]                           }
[17:29:44.987]                         }
[17:29:44.987]                       }
[17:29:44.987]                       invisible(muffled)
[17:29:44.987]                     }
[17:29:44.987]                     muffleCondition(cond, pattern = "^muffle")
[17:29:44.987]                   }
[17:29:44.987]                 }
[17:29:44.987]                 else {
[17:29:44.987]                   if (TRUE) {
[17:29:44.987]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:44.987]                     {
[17:29:44.987]                       inherits <- base::inherits
[17:29:44.987]                       invokeRestart <- base::invokeRestart
[17:29:44.987]                       is.null <- base::is.null
[17:29:44.987]                       muffled <- FALSE
[17:29:44.987]                       if (inherits(cond, "message")) {
[17:29:44.987]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:44.987]                         if (muffled) 
[17:29:44.987]                           invokeRestart("muffleMessage")
[17:29:44.987]                       }
[17:29:44.987]                       else if (inherits(cond, "warning")) {
[17:29:44.987]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:44.987]                         if (muffled) 
[17:29:44.987]                           invokeRestart("muffleWarning")
[17:29:44.987]                       }
[17:29:44.987]                       else if (inherits(cond, "condition")) {
[17:29:44.987]                         if (!is.null(pattern)) {
[17:29:44.987]                           computeRestarts <- base::computeRestarts
[17:29:44.987]                           grepl <- base::grepl
[17:29:44.987]                           restarts <- computeRestarts(cond)
[17:29:44.987]                           for (restart in restarts) {
[17:29:44.987]                             name <- restart$name
[17:29:44.987]                             if (is.null(name)) 
[17:29:44.987]                               next
[17:29:44.987]                             if (!grepl(pattern, name)) 
[17:29:44.987]                               next
[17:29:44.987]                             invokeRestart(restart)
[17:29:44.987]                             muffled <- TRUE
[17:29:44.987]                             break
[17:29:44.987]                           }
[17:29:44.987]                         }
[17:29:44.987]                       }
[17:29:44.987]                       invisible(muffled)
[17:29:44.987]                     }
[17:29:44.987]                     muffleCondition(cond, pattern = "^muffle")
[17:29:44.987]                   }
[17:29:44.987]                 }
[17:29:44.987]             }
[17:29:44.987]         }))
[17:29:44.987]     }, error = function(ex) {
[17:29:44.987]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:44.987]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:44.987]                 ...future.rng), started = ...future.startTime, 
[17:29:44.987]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:44.987]             version = "1.8"), class = "FutureResult")
[17:29:44.987]     }, finally = {
[17:29:44.987]         if (!identical(...future.workdir, getwd())) 
[17:29:44.987]             setwd(...future.workdir)
[17:29:44.987]         {
[17:29:44.987]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:44.987]                 ...future.oldOptions$nwarnings <- NULL
[17:29:44.987]             }
[17:29:44.987]             base::options(...future.oldOptions)
[17:29:44.987]             if (.Platform$OS.type == "windows") {
[17:29:44.987]                 old_names <- names(...future.oldEnvVars)
[17:29:44.987]                 envs <- base::Sys.getenv()
[17:29:44.987]                 names <- names(envs)
[17:29:44.987]                 common <- intersect(names, old_names)
[17:29:44.987]                 added <- setdiff(names, old_names)
[17:29:44.987]                 removed <- setdiff(old_names, names)
[17:29:44.987]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:44.987]                   envs[common]]
[17:29:44.987]                 NAMES <- toupper(changed)
[17:29:44.987]                 args <- list()
[17:29:44.987]                 for (kk in seq_along(NAMES)) {
[17:29:44.987]                   name <- changed[[kk]]
[17:29:44.987]                   NAME <- NAMES[[kk]]
[17:29:44.987]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.987]                     next
[17:29:44.987]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:44.987]                 }
[17:29:44.987]                 NAMES <- toupper(added)
[17:29:44.987]                 for (kk in seq_along(NAMES)) {
[17:29:44.987]                   name <- added[[kk]]
[17:29:44.987]                   NAME <- NAMES[[kk]]
[17:29:44.987]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.987]                     next
[17:29:44.987]                   args[[name]] <- ""
[17:29:44.987]                 }
[17:29:44.987]                 NAMES <- toupper(removed)
[17:29:44.987]                 for (kk in seq_along(NAMES)) {
[17:29:44.987]                   name <- removed[[kk]]
[17:29:44.987]                   NAME <- NAMES[[kk]]
[17:29:44.987]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:44.987]                     next
[17:29:44.987]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:44.987]                 }
[17:29:44.987]                 if (length(args) > 0) 
[17:29:44.987]                   base::do.call(base::Sys.setenv, args = args)
[17:29:44.987]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:44.987]             }
[17:29:44.987]             else {
[17:29:44.987]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:44.987]             }
[17:29:44.987]             {
[17:29:44.987]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:44.987]                   0L) {
[17:29:44.987]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:44.987]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:44.987]                   base::options(opts)
[17:29:44.987]                 }
[17:29:44.987]                 {
[17:29:44.987]                   {
[17:29:44.987]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:44.987]                     NULL
[17:29:44.987]                   }
[17:29:44.987]                   options(future.plan = NULL)
[17:29:44.987]                   if (is.na(NA_character_)) 
[17:29:44.987]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:44.987]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:44.987]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:44.987]                     .init = FALSE)
[17:29:44.987]                 }
[17:29:44.987]             }
[17:29:44.987]         }
[17:29:44.987]     })
[17:29:44.987]     if (TRUE) {
[17:29:44.987]         base::sink(type = "output", split = FALSE)
[17:29:44.987]         if (TRUE) {
[17:29:44.987]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:44.987]         }
[17:29:44.987]         else {
[17:29:44.987]             ...future.result["stdout"] <- base::list(NULL)
[17:29:44.987]         }
[17:29:44.987]         base::close(...future.stdout)
[17:29:44.987]         ...future.stdout <- NULL
[17:29:44.987]     }
[17:29:44.987]     ...future.result$conditions <- ...future.conditions
[17:29:44.987]     ...future.result$finished <- base::Sys.time()
[17:29:44.987]     ...future.result
[17:29:44.987] }
[17:29:44.993] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:44.993] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:44.993] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:44.993] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:44.994] MultisessionFuture started
[17:29:44.994] - Launch lazy future ... done
[17:29:44.995] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_1-12558'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001adda363ca8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:29:45.010] receiveMessageFromWorker() for ClusterFuture ...
[17:29:45.010] - Validating connection of MultisessionFuture
[17:29:45.011] - received message: FutureResult
[17:29:45.011] - Received FutureResult
[17:29:45.011] - Erased future from FutureRegistry
[17:29:45.011] result() for ClusterFuture ...
[17:29:45.011] - result already collected: FutureResult
[17:29:45.012] result() for ClusterFuture ... done
[17:29:45.012] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.012] getGlobalsAndPackages() ...
[17:29:45.012] Searching for globals...
[17:29:45.014] - globals found: [3] '{', 'sample', 'x'
[17:29:45.014] Searching for globals ... DONE
[17:29:45.014] Resolving globals: FALSE
[17:29:45.014] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:45.015] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:45.015] - globals: [1] 'x'
[17:29:45.015] 
[17:29:45.015] getGlobalsAndPackages() ... DONE
[17:29:45.016] run() for 'Future' ...
[17:29:45.016] - state: 'created'
[17:29:45.016] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:45.032] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.032] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:45.033]   - Field: 'node'
[17:29:45.033]   - Field: 'label'
[17:29:45.033]   - Field: 'local'
[17:29:45.034]   - Field: 'owner'
[17:29:45.034]   - Field: 'envir'
[17:29:45.034]   - Field: 'workers'
[17:29:45.034]   - Field: 'packages'
[17:29:45.035]   - Field: 'gc'
[17:29:45.035]   - Field: 'conditions'
[17:29:45.035]   - Field: 'persistent'
[17:29:45.036]   - Field: 'expr'
[17:29:45.036]   - Field: 'uuid'
[17:29:45.036]   - Field: 'seed'
[17:29:45.037]   - Field: 'version'
[17:29:45.037]   - Field: 'result'
[17:29:45.037]   - Field: 'asynchronous'
[17:29:45.038]   - Field: 'calls'
[17:29:45.038]   - Field: 'globals'
[17:29:45.038]   - Field: 'stdout'
[17:29:45.039]   - Field: 'earlySignal'
[17:29:45.039]   - Field: 'lazy'
[17:29:45.039]   - Field: 'state'
[17:29:45.040] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:45.040] - Launch lazy future ...
[17:29:45.040] Packages needed by the future expression (n = 0): <none>
[17:29:45.041] Packages needed by future strategies (n = 0): <none>
[17:29:45.042] {
[17:29:45.042]     {
[17:29:45.042]         {
[17:29:45.042]             ...future.startTime <- base::Sys.time()
[17:29:45.042]             {
[17:29:45.042]                 {
[17:29:45.042]                   {
[17:29:45.042]                     {
[17:29:45.042]                       base::local({
[17:29:45.042]                         has_future <- base::requireNamespace("future", 
[17:29:45.042]                           quietly = TRUE)
[17:29:45.042]                         if (has_future) {
[17:29:45.042]                           ns <- base::getNamespace("future")
[17:29:45.042]                           version <- ns[[".package"]][["version"]]
[17:29:45.042]                           if (is.null(version)) 
[17:29:45.042]                             version <- utils::packageVersion("future")
[17:29:45.042]                         }
[17:29:45.042]                         else {
[17:29:45.042]                           version <- NULL
[17:29:45.042]                         }
[17:29:45.042]                         if (!has_future || version < "1.8.0") {
[17:29:45.042]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:45.042]                             "", base::R.version$version.string), 
[17:29:45.042]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:45.042]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:45.042]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:45.042]                               "release", "version")], collapse = " "), 
[17:29:45.042]                             hostname = base::Sys.info()[["nodename"]])
[17:29:45.042]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:45.042]                             info)
[17:29:45.042]                           info <- base::paste(info, collapse = "; ")
[17:29:45.042]                           if (!has_future) {
[17:29:45.042]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:45.042]                               info)
[17:29:45.042]                           }
[17:29:45.042]                           else {
[17:29:45.042]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:45.042]                               info, version)
[17:29:45.042]                           }
[17:29:45.042]                           base::stop(msg)
[17:29:45.042]                         }
[17:29:45.042]                       })
[17:29:45.042]                     }
[17:29:45.042]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:45.042]                     base::options(mc.cores = 1L)
[17:29:45.042]                   }
[17:29:45.042]                   ...future.strategy.old <- future::plan("list")
[17:29:45.042]                   options(future.plan = NULL)
[17:29:45.042]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.042]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:45.042]                 }
[17:29:45.042]                 ...future.workdir <- getwd()
[17:29:45.042]             }
[17:29:45.042]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:45.042]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:45.042]         }
[17:29:45.042]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:45.042]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:45.042]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:45.042]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:45.042]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:45.042]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:45.042]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:45.042]             base::names(...future.oldOptions))
[17:29:45.042]     }
[17:29:45.042]     if (FALSE) {
[17:29:45.042]     }
[17:29:45.042]     else {
[17:29:45.042]         if (TRUE) {
[17:29:45.042]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:45.042]                 open = "w")
[17:29:45.042]         }
[17:29:45.042]         else {
[17:29:45.042]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:45.042]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:45.042]         }
[17:29:45.042]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:45.042]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:45.042]             base::sink(type = "output", split = FALSE)
[17:29:45.042]             base::close(...future.stdout)
[17:29:45.042]         }, add = TRUE)
[17:29:45.042]     }
[17:29:45.042]     ...future.frame <- base::sys.nframe()
[17:29:45.042]     ...future.conditions <- base::list()
[17:29:45.042]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:45.042]     if (FALSE) {
[17:29:45.042]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:45.042]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:45.042]     }
[17:29:45.042]     ...future.result <- base::tryCatch({
[17:29:45.042]         base::withCallingHandlers({
[17:29:45.042]             ...future.value <- base::withVisible(base::local({
[17:29:45.042]                 ...future.makeSendCondition <- base::local({
[17:29:45.042]                   sendCondition <- NULL
[17:29:45.042]                   function(frame = 1L) {
[17:29:45.042]                     if (is.function(sendCondition)) 
[17:29:45.042]                       return(sendCondition)
[17:29:45.042]                     ns <- getNamespace("parallel")
[17:29:45.042]                     if (exists("sendData", mode = "function", 
[17:29:45.042]                       envir = ns)) {
[17:29:45.042]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:45.042]                         envir = ns)
[17:29:45.042]                       envir <- sys.frame(frame)
[17:29:45.042]                       master <- NULL
[17:29:45.042]                       while (!identical(envir, .GlobalEnv) && 
[17:29:45.042]                         !identical(envir, emptyenv())) {
[17:29:45.042]                         if (exists("master", mode = "list", envir = envir, 
[17:29:45.042]                           inherits = FALSE)) {
[17:29:45.042]                           master <- get("master", mode = "list", 
[17:29:45.042]                             envir = envir, inherits = FALSE)
[17:29:45.042]                           if (inherits(master, c("SOCKnode", 
[17:29:45.042]                             "SOCK0node"))) {
[17:29:45.042]                             sendCondition <<- function(cond) {
[17:29:45.042]                               data <- list(type = "VALUE", value = cond, 
[17:29:45.042]                                 success = TRUE)
[17:29:45.042]                               parallel_sendData(master, data)
[17:29:45.042]                             }
[17:29:45.042]                             return(sendCondition)
[17:29:45.042]                           }
[17:29:45.042]                         }
[17:29:45.042]                         frame <- frame + 1L
[17:29:45.042]                         envir <- sys.frame(frame)
[17:29:45.042]                       }
[17:29:45.042]                     }
[17:29:45.042]                     sendCondition <<- function(cond) NULL
[17:29:45.042]                   }
[17:29:45.042]                 })
[17:29:45.042]                 withCallingHandlers({
[17:29:45.042]                   {
[17:29:45.042]                     sample(x, size = 1L)
[17:29:45.042]                   }
[17:29:45.042]                 }, immediateCondition = function(cond) {
[17:29:45.042]                   sendCondition <- ...future.makeSendCondition()
[17:29:45.042]                   sendCondition(cond)
[17:29:45.042]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.042]                   {
[17:29:45.042]                     inherits <- base::inherits
[17:29:45.042]                     invokeRestart <- base::invokeRestart
[17:29:45.042]                     is.null <- base::is.null
[17:29:45.042]                     muffled <- FALSE
[17:29:45.042]                     if (inherits(cond, "message")) {
[17:29:45.042]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:45.042]                       if (muffled) 
[17:29:45.042]                         invokeRestart("muffleMessage")
[17:29:45.042]                     }
[17:29:45.042]                     else if (inherits(cond, "warning")) {
[17:29:45.042]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:45.042]                       if (muffled) 
[17:29:45.042]                         invokeRestart("muffleWarning")
[17:29:45.042]                     }
[17:29:45.042]                     else if (inherits(cond, "condition")) {
[17:29:45.042]                       if (!is.null(pattern)) {
[17:29:45.042]                         computeRestarts <- base::computeRestarts
[17:29:45.042]                         grepl <- base::grepl
[17:29:45.042]                         restarts <- computeRestarts(cond)
[17:29:45.042]                         for (restart in restarts) {
[17:29:45.042]                           name <- restart$name
[17:29:45.042]                           if (is.null(name)) 
[17:29:45.042]                             next
[17:29:45.042]                           if (!grepl(pattern, name)) 
[17:29:45.042]                             next
[17:29:45.042]                           invokeRestart(restart)
[17:29:45.042]                           muffled <- TRUE
[17:29:45.042]                           break
[17:29:45.042]                         }
[17:29:45.042]                       }
[17:29:45.042]                     }
[17:29:45.042]                     invisible(muffled)
[17:29:45.042]                   }
[17:29:45.042]                   muffleCondition(cond)
[17:29:45.042]                 })
[17:29:45.042]             }))
[17:29:45.042]             future::FutureResult(value = ...future.value$value, 
[17:29:45.042]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.042]                   ...future.rng), globalenv = if (FALSE) 
[17:29:45.042]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:45.042]                     ...future.globalenv.names))
[17:29:45.042]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:45.042]         }, condition = base::local({
[17:29:45.042]             c <- base::c
[17:29:45.042]             inherits <- base::inherits
[17:29:45.042]             invokeRestart <- base::invokeRestart
[17:29:45.042]             length <- base::length
[17:29:45.042]             list <- base::list
[17:29:45.042]             seq.int <- base::seq.int
[17:29:45.042]             signalCondition <- base::signalCondition
[17:29:45.042]             sys.calls <- base::sys.calls
[17:29:45.042]             `[[` <- base::`[[`
[17:29:45.042]             `+` <- base::`+`
[17:29:45.042]             `<<-` <- base::`<<-`
[17:29:45.042]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:45.042]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:45.042]                   3L)]
[17:29:45.042]             }
[17:29:45.042]             function(cond) {
[17:29:45.042]                 is_error <- inherits(cond, "error")
[17:29:45.042]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:45.042]                   NULL)
[17:29:45.042]                 if (is_error) {
[17:29:45.042]                   sessionInformation <- function() {
[17:29:45.042]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:45.042]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:45.042]                       search = base::search(), system = base::Sys.info())
[17:29:45.042]                   }
[17:29:45.042]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.042]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:45.042]                     cond$call), session = sessionInformation(), 
[17:29:45.042]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:45.042]                   signalCondition(cond)
[17:29:45.042]                 }
[17:29:45.042]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:45.042]                 "immediateCondition"))) {
[17:29:45.042]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:45.042]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.042]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:45.042]                   if (TRUE && !signal) {
[17:29:45.042]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.042]                     {
[17:29:45.042]                       inherits <- base::inherits
[17:29:45.042]                       invokeRestart <- base::invokeRestart
[17:29:45.042]                       is.null <- base::is.null
[17:29:45.042]                       muffled <- FALSE
[17:29:45.042]                       if (inherits(cond, "message")) {
[17:29:45.042]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.042]                         if (muffled) 
[17:29:45.042]                           invokeRestart("muffleMessage")
[17:29:45.042]                       }
[17:29:45.042]                       else if (inherits(cond, "warning")) {
[17:29:45.042]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.042]                         if (muffled) 
[17:29:45.042]                           invokeRestart("muffleWarning")
[17:29:45.042]                       }
[17:29:45.042]                       else if (inherits(cond, "condition")) {
[17:29:45.042]                         if (!is.null(pattern)) {
[17:29:45.042]                           computeRestarts <- base::computeRestarts
[17:29:45.042]                           grepl <- base::grepl
[17:29:45.042]                           restarts <- computeRestarts(cond)
[17:29:45.042]                           for (restart in restarts) {
[17:29:45.042]                             name <- restart$name
[17:29:45.042]                             if (is.null(name)) 
[17:29:45.042]                               next
[17:29:45.042]                             if (!grepl(pattern, name)) 
[17:29:45.042]                               next
[17:29:45.042]                             invokeRestart(restart)
[17:29:45.042]                             muffled <- TRUE
[17:29:45.042]                             break
[17:29:45.042]                           }
[17:29:45.042]                         }
[17:29:45.042]                       }
[17:29:45.042]                       invisible(muffled)
[17:29:45.042]                     }
[17:29:45.042]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.042]                   }
[17:29:45.042]                 }
[17:29:45.042]                 else {
[17:29:45.042]                   if (TRUE) {
[17:29:45.042]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.042]                     {
[17:29:45.042]                       inherits <- base::inherits
[17:29:45.042]                       invokeRestart <- base::invokeRestart
[17:29:45.042]                       is.null <- base::is.null
[17:29:45.042]                       muffled <- FALSE
[17:29:45.042]                       if (inherits(cond, "message")) {
[17:29:45.042]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.042]                         if (muffled) 
[17:29:45.042]                           invokeRestart("muffleMessage")
[17:29:45.042]                       }
[17:29:45.042]                       else if (inherits(cond, "warning")) {
[17:29:45.042]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.042]                         if (muffled) 
[17:29:45.042]                           invokeRestart("muffleWarning")
[17:29:45.042]                       }
[17:29:45.042]                       else if (inherits(cond, "condition")) {
[17:29:45.042]                         if (!is.null(pattern)) {
[17:29:45.042]                           computeRestarts <- base::computeRestarts
[17:29:45.042]                           grepl <- base::grepl
[17:29:45.042]                           restarts <- computeRestarts(cond)
[17:29:45.042]                           for (restart in restarts) {
[17:29:45.042]                             name <- restart$name
[17:29:45.042]                             if (is.null(name)) 
[17:29:45.042]                               next
[17:29:45.042]                             if (!grepl(pattern, name)) 
[17:29:45.042]                               next
[17:29:45.042]                             invokeRestart(restart)
[17:29:45.042]                             muffled <- TRUE
[17:29:45.042]                             break
[17:29:45.042]                           }
[17:29:45.042]                         }
[17:29:45.042]                       }
[17:29:45.042]                       invisible(muffled)
[17:29:45.042]                     }
[17:29:45.042]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.042]                   }
[17:29:45.042]                 }
[17:29:45.042]             }
[17:29:45.042]         }))
[17:29:45.042]     }, error = function(ex) {
[17:29:45.042]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:45.042]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.042]                 ...future.rng), started = ...future.startTime, 
[17:29:45.042]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:45.042]             version = "1.8"), class = "FutureResult")
[17:29:45.042]     }, finally = {
[17:29:45.042]         if (!identical(...future.workdir, getwd())) 
[17:29:45.042]             setwd(...future.workdir)
[17:29:45.042]         {
[17:29:45.042]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:45.042]                 ...future.oldOptions$nwarnings <- NULL
[17:29:45.042]             }
[17:29:45.042]             base::options(...future.oldOptions)
[17:29:45.042]             if (.Platform$OS.type == "windows") {
[17:29:45.042]                 old_names <- names(...future.oldEnvVars)
[17:29:45.042]                 envs <- base::Sys.getenv()
[17:29:45.042]                 names <- names(envs)
[17:29:45.042]                 common <- intersect(names, old_names)
[17:29:45.042]                 added <- setdiff(names, old_names)
[17:29:45.042]                 removed <- setdiff(old_names, names)
[17:29:45.042]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:45.042]                   envs[common]]
[17:29:45.042]                 NAMES <- toupper(changed)
[17:29:45.042]                 args <- list()
[17:29:45.042]                 for (kk in seq_along(NAMES)) {
[17:29:45.042]                   name <- changed[[kk]]
[17:29:45.042]                   NAME <- NAMES[[kk]]
[17:29:45.042]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.042]                     next
[17:29:45.042]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.042]                 }
[17:29:45.042]                 NAMES <- toupper(added)
[17:29:45.042]                 for (kk in seq_along(NAMES)) {
[17:29:45.042]                   name <- added[[kk]]
[17:29:45.042]                   NAME <- NAMES[[kk]]
[17:29:45.042]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.042]                     next
[17:29:45.042]                   args[[name]] <- ""
[17:29:45.042]                 }
[17:29:45.042]                 NAMES <- toupper(removed)
[17:29:45.042]                 for (kk in seq_along(NAMES)) {
[17:29:45.042]                   name <- removed[[kk]]
[17:29:45.042]                   NAME <- NAMES[[kk]]
[17:29:45.042]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.042]                     next
[17:29:45.042]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.042]                 }
[17:29:45.042]                 if (length(args) > 0) 
[17:29:45.042]                   base::do.call(base::Sys.setenv, args = args)
[17:29:45.042]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:45.042]             }
[17:29:45.042]             else {
[17:29:45.042]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:45.042]             }
[17:29:45.042]             {
[17:29:45.042]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:45.042]                   0L) {
[17:29:45.042]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:45.042]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:45.042]                   base::options(opts)
[17:29:45.042]                 }
[17:29:45.042]                 {
[17:29:45.042]                   {
[17:29:45.042]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:45.042]                     NULL
[17:29:45.042]                   }
[17:29:45.042]                   options(future.plan = NULL)
[17:29:45.042]                   if (is.na(NA_character_)) 
[17:29:45.042]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.042]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:45.042]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:45.042]                     .init = FALSE)
[17:29:45.042]                 }
[17:29:45.042]             }
[17:29:45.042]         }
[17:29:45.042]     })
[17:29:45.042]     if (TRUE) {
[17:29:45.042]         base::sink(type = "output", split = FALSE)
[17:29:45.042]         if (TRUE) {
[17:29:45.042]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:45.042]         }
[17:29:45.042]         else {
[17:29:45.042]             ...future.result["stdout"] <- base::list(NULL)
[17:29:45.042]         }
[17:29:45.042]         base::close(...future.stdout)
[17:29:45.042]         ...future.stdout <- NULL
[17:29:45.042]     }
[17:29:45.042]     ...future.result$conditions <- ...future.conditions
[17:29:45.042]     ...future.result$finished <- base::Sys.time()
[17:29:45.042]     ...future.result
[17:29:45.042] }
[17:29:45.050] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:45.051] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:45.053] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:45.053] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:45.054] MultisessionFuture started
[17:29:45.054] - Launch lazy future ... done
[17:29:45.055] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_2-78564'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001adda363ca8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:29:45.078] receiveMessageFromWorker() for ClusterFuture ...
[17:29:45.079] - Validating connection of MultisessionFuture
[17:29:45.079] - received message: FutureResult
[17:29:45.080] - Received FutureResult
[17:29:45.080] - Erased future from FutureRegistry
[17:29:45.080] result() for ClusterFuture ...
[17:29:45.080] - result already collected: FutureResult
[17:29:45.080] result() for ClusterFuture ... done
[17:29:45.081] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.081] getGlobalsAndPackages() ...
[17:29:45.081] Searching for globals...
[17:29:45.083] - globals found: [3] '{', 'sample', 'x'
[17:29:45.083] Searching for globals ... DONE
[17:29:45.084] Resolving globals: FALSE
[17:29:45.084] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:45.085] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:45.085] - globals: [1] 'x'
[17:29:45.085] 
[17:29:45.085] getGlobalsAndPackages() ... DONE
[17:29:45.086] run() for 'Future' ...
[17:29:45.086] - state: 'created'
[17:29:45.087] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:45.105] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.105] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:45.106]   - Field: 'node'
[17:29:45.106]   - Field: 'label'
[17:29:45.106]   - Field: 'local'
[17:29:45.106]   - Field: 'owner'
[17:29:45.107]   - Field: 'envir'
[17:29:45.107]   - Field: 'workers'
[17:29:45.107]   - Field: 'packages'
[17:29:45.108]   - Field: 'gc'
[17:29:45.108]   - Field: 'conditions'
[17:29:45.108]   - Field: 'persistent'
[17:29:45.108]   - Field: 'expr'
[17:29:45.109]   - Field: 'uuid'
[17:29:45.109]   - Field: 'seed'
[17:29:45.109]   - Field: 'version'
[17:29:45.109]   - Field: 'result'
[17:29:45.110]   - Field: 'asynchronous'
[17:29:45.110]   - Field: 'calls'
[17:29:45.110]   - Field: 'globals'
[17:29:45.110]   - Field: 'stdout'
[17:29:45.110]   - Field: 'earlySignal'
[17:29:45.111]   - Field: 'lazy'
[17:29:45.111]   - Field: 'state'
[17:29:45.111] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:45.111] - Launch lazy future ...
[17:29:45.112] Packages needed by the future expression (n = 0): <none>
[17:29:45.112] Packages needed by future strategies (n = 0): <none>
[17:29:45.113] {
[17:29:45.113]     {
[17:29:45.113]         {
[17:29:45.113]             ...future.startTime <- base::Sys.time()
[17:29:45.113]             {
[17:29:45.113]                 {
[17:29:45.113]                   {
[17:29:45.113]                     {
[17:29:45.113]                       base::local({
[17:29:45.113]                         has_future <- base::requireNamespace("future", 
[17:29:45.113]                           quietly = TRUE)
[17:29:45.113]                         if (has_future) {
[17:29:45.113]                           ns <- base::getNamespace("future")
[17:29:45.113]                           version <- ns[[".package"]][["version"]]
[17:29:45.113]                           if (is.null(version)) 
[17:29:45.113]                             version <- utils::packageVersion("future")
[17:29:45.113]                         }
[17:29:45.113]                         else {
[17:29:45.113]                           version <- NULL
[17:29:45.113]                         }
[17:29:45.113]                         if (!has_future || version < "1.8.0") {
[17:29:45.113]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:45.113]                             "", base::R.version$version.string), 
[17:29:45.113]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:45.113]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:45.113]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:45.113]                               "release", "version")], collapse = " "), 
[17:29:45.113]                             hostname = base::Sys.info()[["nodename"]])
[17:29:45.113]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:45.113]                             info)
[17:29:45.113]                           info <- base::paste(info, collapse = "; ")
[17:29:45.113]                           if (!has_future) {
[17:29:45.113]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:45.113]                               info)
[17:29:45.113]                           }
[17:29:45.113]                           else {
[17:29:45.113]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:45.113]                               info, version)
[17:29:45.113]                           }
[17:29:45.113]                           base::stop(msg)
[17:29:45.113]                         }
[17:29:45.113]                       })
[17:29:45.113]                     }
[17:29:45.113]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:45.113]                     base::options(mc.cores = 1L)
[17:29:45.113]                   }
[17:29:45.113]                   ...future.strategy.old <- future::plan("list")
[17:29:45.113]                   options(future.plan = NULL)
[17:29:45.113]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.113]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:45.113]                 }
[17:29:45.113]                 ...future.workdir <- getwd()
[17:29:45.113]             }
[17:29:45.113]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:45.113]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:45.113]         }
[17:29:45.113]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:45.113]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:45.113]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:45.113]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:45.113]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:45.113]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:45.113]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:45.113]             base::names(...future.oldOptions))
[17:29:45.113]     }
[17:29:45.113]     if (FALSE) {
[17:29:45.113]     }
[17:29:45.113]     else {
[17:29:45.113]         if (TRUE) {
[17:29:45.113]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:45.113]                 open = "w")
[17:29:45.113]         }
[17:29:45.113]         else {
[17:29:45.113]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:45.113]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:45.113]         }
[17:29:45.113]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:45.113]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:45.113]             base::sink(type = "output", split = FALSE)
[17:29:45.113]             base::close(...future.stdout)
[17:29:45.113]         }, add = TRUE)
[17:29:45.113]     }
[17:29:45.113]     ...future.frame <- base::sys.nframe()
[17:29:45.113]     ...future.conditions <- base::list()
[17:29:45.113]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:45.113]     if (FALSE) {
[17:29:45.113]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:45.113]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:45.113]     }
[17:29:45.113]     ...future.result <- base::tryCatch({
[17:29:45.113]         base::withCallingHandlers({
[17:29:45.113]             ...future.value <- base::withVisible(base::local({
[17:29:45.113]                 ...future.makeSendCondition <- base::local({
[17:29:45.113]                   sendCondition <- NULL
[17:29:45.113]                   function(frame = 1L) {
[17:29:45.113]                     if (is.function(sendCondition)) 
[17:29:45.113]                       return(sendCondition)
[17:29:45.113]                     ns <- getNamespace("parallel")
[17:29:45.113]                     if (exists("sendData", mode = "function", 
[17:29:45.113]                       envir = ns)) {
[17:29:45.113]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:45.113]                         envir = ns)
[17:29:45.113]                       envir <- sys.frame(frame)
[17:29:45.113]                       master <- NULL
[17:29:45.113]                       while (!identical(envir, .GlobalEnv) && 
[17:29:45.113]                         !identical(envir, emptyenv())) {
[17:29:45.113]                         if (exists("master", mode = "list", envir = envir, 
[17:29:45.113]                           inherits = FALSE)) {
[17:29:45.113]                           master <- get("master", mode = "list", 
[17:29:45.113]                             envir = envir, inherits = FALSE)
[17:29:45.113]                           if (inherits(master, c("SOCKnode", 
[17:29:45.113]                             "SOCK0node"))) {
[17:29:45.113]                             sendCondition <<- function(cond) {
[17:29:45.113]                               data <- list(type = "VALUE", value = cond, 
[17:29:45.113]                                 success = TRUE)
[17:29:45.113]                               parallel_sendData(master, data)
[17:29:45.113]                             }
[17:29:45.113]                             return(sendCondition)
[17:29:45.113]                           }
[17:29:45.113]                         }
[17:29:45.113]                         frame <- frame + 1L
[17:29:45.113]                         envir <- sys.frame(frame)
[17:29:45.113]                       }
[17:29:45.113]                     }
[17:29:45.113]                     sendCondition <<- function(cond) NULL
[17:29:45.113]                   }
[17:29:45.113]                 })
[17:29:45.113]                 withCallingHandlers({
[17:29:45.113]                   {
[17:29:45.113]                     sample(x, size = 1L)
[17:29:45.113]                   }
[17:29:45.113]                 }, immediateCondition = function(cond) {
[17:29:45.113]                   sendCondition <- ...future.makeSendCondition()
[17:29:45.113]                   sendCondition(cond)
[17:29:45.113]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.113]                   {
[17:29:45.113]                     inherits <- base::inherits
[17:29:45.113]                     invokeRestart <- base::invokeRestart
[17:29:45.113]                     is.null <- base::is.null
[17:29:45.113]                     muffled <- FALSE
[17:29:45.113]                     if (inherits(cond, "message")) {
[17:29:45.113]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:45.113]                       if (muffled) 
[17:29:45.113]                         invokeRestart("muffleMessage")
[17:29:45.113]                     }
[17:29:45.113]                     else if (inherits(cond, "warning")) {
[17:29:45.113]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:45.113]                       if (muffled) 
[17:29:45.113]                         invokeRestart("muffleWarning")
[17:29:45.113]                     }
[17:29:45.113]                     else if (inherits(cond, "condition")) {
[17:29:45.113]                       if (!is.null(pattern)) {
[17:29:45.113]                         computeRestarts <- base::computeRestarts
[17:29:45.113]                         grepl <- base::grepl
[17:29:45.113]                         restarts <- computeRestarts(cond)
[17:29:45.113]                         for (restart in restarts) {
[17:29:45.113]                           name <- restart$name
[17:29:45.113]                           if (is.null(name)) 
[17:29:45.113]                             next
[17:29:45.113]                           if (!grepl(pattern, name)) 
[17:29:45.113]                             next
[17:29:45.113]                           invokeRestart(restart)
[17:29:45.113]                           muffled <- TRUE
[17:29:45.113]                           break
[17:29:45.113]                         }
[17:29:45.113]                       }
[17:29:45.113]                     }
[17:29:45.113]                     invisible(muffled)
[17:29:45.113]                   }
[17:29:45.113]                   muffleCondition(cond)
[17:29:45.113]                 })
[17:29:45.113]             }))
[17:29:45.113]             future::FutureResult(value = ...future.value$value, 
[17:29:45.113]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.113]                   ...future.rng), globalenv = if (FALSE) 
[17:29:45.113]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:45.113]                     ...future.globalenv.names))
[17:29:45.113]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:45.113]         }, condition = base::local({
[17:29:45.113]             c <- base::c
[17:29:45.113]             inherits <- base::inherits
[17:29:45.113]             invokeRestart <- base::invokeRestart
[17:29:45.113]             length <- base::length
[17:29:45.113]             list <- base::list
[17:29:45.113]             seq.int <- base::seq.int
[17:29:45.113]             signalCondition <- base::signalCondition
[17:29:45.113]             sys.calls <- base::sys.calls
[17:29:45.113]             `[[` <- base::`[[`
[17:29:45.113]             `+` <- base::`+`
[17:29:45.113]             `<<-` <- base::`<<-`
[17:29:45.113]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:45.113]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:45.113]                   3L)]
[17:29:45.113]             }
[17:29:45.113]             function(cond) {
[17:29:45.113]                 is_error <- inherits(cond, "error")
[17:29:45.113]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:45.113]                   NULL)
[17:29:45.113]                 if (is_error) {
[17:29:45.113]                   sessionInformation <- function() {
[17:29:45.113]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:45.113]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:45.113]                       search = base::search(), system = base::Sys.info())
[17:29:45.113]                   }
[17:29:45.113]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.113]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:45.113]                     cond$call), session = sessionInformation(), 
[17:29:45.113]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:45.113]                   signalCondition(cond)
[17:29:45.113]                 }
[17:29:45.113]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:45.113]                 "immediateCondition"))) {
[17:29:45.113]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:45.113]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.113]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:45.113]                   if (TRUE && !signal) {
[17:29:45.113]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.113]                     {
[17:29:45.113]                       inherits <- base::inherits
[17:29:45.113]                       invokeRestart <- base::invokeRestart
[17:29:45.113]                       is.null <- base::is.null
[17:29:45.113]                       muffled <- FALSE
[17:29:45.113]                       if (inherits(cond, "message")) {
[17:29:45.113]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.113]                         if (muffled) 
[17:29:45.113]                           invokeRestart("muffleMessage")
[17:29:45.113]                       }
[17:29:45.113]                       else if (inherits(cond, "warning")) {
[17:29:45.113]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.113]                         if (muffled) 
[17:29:45.113]                           invokeRestart("muffleWarning")
[17:29:45.113]                       }
[17:29:45.113]                       else if (inherits(cond, "condition")) {
[17:29:45.113]                         if (!is.null(pattern)) {
[17:29:45.113]                           computeRestarts <- base::computeRestarts
[17:29:45.113]                           grepl <- base::grepl
[17:29:45.113]                           restarts <- computeRestarts(cond)
[17:29:45.113]                           for (restart in restarts) {
[17:29:45.113]                             name <- restart$name
[17:29:45.113]                             if (is.null(name)) 
[17:29:45.113]                               next
[17:29:45.113]                             if (!grepl(pattern, name)) 
[17:29:45.113]                               next
[17:29:45.113]                             invokeRestart(restart)
[17:29:45.113]                             muffled <- TRUE
[17:29:45.113]                             break
[17:29:45.113]                           }
[17:29:45.113]                         }
[17:29:45.113]                       }
[17:29:45.113]                       invisible(muffled)
[17:29:45.113]                     }
[17:29:45.113]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.113]                   }
[17:29:45.113]                 }
[17:29:45.113]                 else {
[17:29:45.113]                   if (TRUE) {
[17:29:45.113]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.113]                     {
[17:29:45.113]                       inherits <- base::inherits
[17:29:45.113]                       invokeRestart <- base::invokeRestart
[17:29:45.113]                       is.null <- base::is.null
[17:29:45.113]                       muffled <- FALSE
[17:29:45.113]                       if (inherits(cond, "message")) {
[17:29:45.113]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.113]                         if (muffled) 
[17:29:45.113]                           invokeRestart("muffleMessage")
[17:29:45.113]                       }
[17:29:45.113]                       else if (inherits(cond, "warning")) {
[17:29:45.113]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.113]                         if (muffled) 
[17:29:45.113]                           invokeRestart("muffleWarning")
[17:29:45.113]                       }
[17:29:45.113]                       else if (inherits(cond, "condition")) {
[17:29:45.113]                         if (!is.null(pattern)) {
[17:29:45.113]                           computeRestarts <- base::computeRestarts
[17:29:45.113]                           grepl <- base::grepl
[17:29:45.113]                           restarts <- computeRestarts(cond)
[17:29:45.113]                           for (restart in restarts) {
[17:29:45.113]                             name <- restart$name
[17:29:45.113]                             if (is.null(name)) 
[17:29:45.113]                               next
[17:29:45.113]                             if (!grepl(pattern, name)) 
[17:29:45.113]                               next
[17:29:45.113]                             invokeRestart(restart)
[17:29:45.113]                             muffled <- TRUE
[17:29:45.113]                             break
[17:29:45.113]                           }
[17:29:45.113]                         }
[17:29:45.113]                       }
[17:29:45.113]                       invisible(muffled)
[17:29:45.113]                     }
[17:29:45.113]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.113]                   }
[17:29:45.113]                 }
[17:29:45.113]             }
[17:29:45.113]         }))
[17:29:45.113]     }, error = function(ex) {
[17:29:45.113]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:45.113]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.113]                 ...future.rng), started = ...future.startTime, 
[17:29:45.113]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:45.113]             version = "1.8"), class = "FutureResult")
[17:29:45.113]     }, finally = {
[17:29:45.113]         if (!identical(...future.workdir, getwd())) 
[17:29:45.113]             setwd(...future.workdir)
[17:29:45.113]         {
[17:29:45.113]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:45.113]                 ...future.oldOptions$nwarnings <- NULL
[17:29:45.113]             }
[17:29:45.113]             base::options(...future.oldOptions)
[17:29:45.113]             if (.Platform$OS.type == "windows") {
[17:29:45.113]                 old_names <- names(...future.oldEnvVars)
[17:29:45.113]                 envs <- base::Sys.getenv()
[17:29:45.113]                 names <- names(envs)
[17:29:45.113]                 common <- intersect(names, old_names)
[17:29:45.113]                 added <- setdiff(names, old_names)
[17:29:45.113]                 removed <- setdiff(old_names, names)
[17:29:45.113]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:45.113]                   envs[common]]
[17:29:45.113]                 NAMES <- toupper(changed)
[17:29:45.113]                 args <- list()
[17:29:45.113]                 for (kk in seq_along(NAMES)) {
[17:29:45.113]                   name <- changed[[kk]]
[17:29:45.113]                   NAME <- NAMES[[kk]]
[17:29:45.113]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.113]                     next
[17:29:45.113]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.113]                 }
[17:29:45.113]                 NAMES <- toupper(added)
[17:29:45.113]                 for (kk in seq_along(NAMES)) {
[17:29:45.113]                   name <- added[[kk]]
[17:29:45.113]                   NAME <- NAMES[[kk]]
[17:29:45.113]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.113]                     next
[17:29:45.113]                   args[[name]] <- ""
[17:29:45.113]                 }
[17:29:45.113]                 NAMES <- toupper(removed)
[17:29:45.113]                 for (kk in seq_along(NAMES)) {
[17:29:45.113]                   name <- removed[[kk]]
[17:29:45.113]                   NAME <- NAMES[[kk]]
[17:29:45.113]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.113]                     next
[17:29:45.113]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.113]                 }
[17:29:45.113]                 if (length(args) > 0) 
[17:29:45.113]                   base::do.call(base::Sys.setenv, args = args)
[17:29:45.113]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:45.113]             }
[17:29:45.113]             else {
[17:29:45.113]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:45.113]             }
[17:29:45.113]             {
[17:29:45.113]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:45.113]                   0L) {
[17:29:45.113]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:45.113]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:45.113]                   base::options(opts)
[17:29:45.113]                 }
[17:29:45.113]                 {
[17:29:45.113]                   {
[17:29:45.113]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:45.113]                     NULL
[17:29:45.113]                   }
[17:29:45.113]                   options(future.plan = NULL)
[17:29:45.113]                   if (is.na(NA_character_)) 
[17:29:45.113]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.113]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:45.113]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:45.113]                     .init = FALSE)
[17:29:45.113]                 }
[17:29:45.113]             }
[17:29:45.113]         }
[17:29:45.113]     })
[17:29:45.113]     if (TRUE) {
[17:29:45.113]         base::sink(type = "output", split = FALSE)
[17:29:45.113]         if (TRUE) {
[17:29:45.113]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:45.113]         }
[17:29:45.113]         else {
[17:29:45.113]             ...future.result["stdout"] <- base::list(NULL)
[17:29:45.113]         }
[17:29:45.113]         base::close(...future.stdout)
[17:29:45.113]         ...future.stdout <- NULL
[17:29:45.113]     }
[17:29:45.113]     ...future.result$conditions <- ...future.conditions
[17:29:45.113]     ...future.result$finished <- base::Sys.time()
[17:29:45.113]     ...future.result
[17:29:45.113] }
[17:29:45.121] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:45.121] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:45.122] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:45.122] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:45.123] MultisessionFuture started
[17:29:45.123] - Launch lazy future ... done
[17:29:45.123] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_3-706101'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001adda363ca8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:29:45.146] receiveMessageFromWorker() for ClusterFuture ...
[17:29:45.146] - Validating connection of MultisessionFuture
[17:29:45.146] - received message: FutureResult
[17:29:45.147] - Received FutureResult
[17:29:45.147] - Erased future from FutureRegistry
[17:29:45.147] result() for ClusterFuture ...
[17:29:45.147] - result already collected: FutureResult
[17:29:45.147] result() for ClusterFuture ... done
[17:29:45.147] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.148] getGlobalsAndPackages() ...
[17:29:45.148] Searching for globals...
[17:29:45.149] - globals found: [3] '{', 'sample', 'x'
[17:29:45.150] Searching for globals ... DONE
[17:29:45.150] Resolving globals: FALSE
[17:29:45.151] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:45.151] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:45.152] - globals: [1] 'x'
[17:29:45.152] 
[17:29:45.152] getGlobalsAndPackages() ... DONE
[17:29:45.153] run() for 'Future' ...
[17:29:45.156] - state: 'created'
[17:29:45.157] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:45.175] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.175] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:45.176]   - Field: 'node'
[17:29:45.176]   - Field: 'label'
[17:29:45.176]   - Field: 'local'
[17:29:45.177]   - Field: 'owner'
[17:29:45.177]   - Field: 'envir'
[17:29:45.177]   - Field: 'workers'
[17:29:45.178]   - Field: 'packages'
[17:29:45.178]   - Field: 'gc'
[17:29:45.178]   - Field: 'conditions'
[17:29:45.179]   - Field: 'persistent'
[17:29:45.179]   - Field: 'expr'
[17:29:45.179]   - Field: 'uuid'
[17:29:45.180]   - Field: 'seed'
[17:29:45.180]   - Field: 'version'
[17:29:45.180]   - Field: 'result'
[17:29:45.180]   - Field: 'asynchronous'
[17:29:45.181]   - Field: 'calls'
[17:29:45.181]   - Field: 'globals'
[17:29:45.181]   - Field: 'stdout'
[17:29:45.182]   - Field: 'earlySignal'
[17:29:45.182]   - Field: 'lazy'
[17:29:45.182]   - Field: 'state'
[17:29:45.182] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:45.183] - Launch lazy future ...
[17:29:45.183] Packages needed by the future expression (n = 0): <none>
[17:29:45.184] Packages needed by future strategies (n = 0): <none>
[17:29:45.185] {
[17:29:45.185]     {
[17:29:45.185]         {
[17:29:45.185]             ...future.startTime <- base::Sys.time()
[17:29:45.185]             {
[17:29:45.185]                 {
[17:29:45.185]                   {
[17:29:45.185]                     {
[17:29:45.185]                       base::local({
[17:29:45.185]                         has_future <- base::requireNamespace("future", 
[17:29:45.185]                           quietly = TRUE)
[17:29:45.185]                         if (has_future) {
[17:29:45.185]                           ns <- base::getNamespace("future")
[17:29:45.185]                           version <- ns[[".package"]][["version"]]
[17:29:45.185]                           if (is.null(version)) 
[17:29:45.185]                             version <- utils::packageVersion("future")
[17:29:45.185]                         }
[17:29:45.185]                         else {
[17:29:45.185]                           version <- NULL
[17:29:45.185]                         }
[17:29:45.185]                         if (!has_future || version < "1.8.0") {
[17:29:45.185]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:45.185]                             "", base::R.version$version.string), 
[17:29:45.185]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:45.185]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:45.185]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:45.185]                               "release", "version")], collapse = " "), 
[17:29:45.185]                             hostname = base::Sys.info()[["nodename"]])
[17:29:45.185]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:45.185]                             info)
[17:29:45.185]                           info <- base::paste(info, collapse = "; ")
[17:29:45.185]                           if (!has_future) {
[17:29:45.185]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:45.185]                               info)
[17:29:45.185]                           }
[17:29:45.185]                           else {
[17:29:45.185]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:45.185]                               info, version)
[17:29:45.185]                           }
[17:29:45.185]                           base::stop(msg)
[17:29:45.185]                         }
[17:29:45.185]                       })
[17:29:45.185]                     }
[17:29:45.185]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:45.185]                     base::options(mc.cores = 1L)
[17:29:45.185]                   }
[17:29:45.185]                   ...future.strategy.old <- future::plan("list")
[17:29:45.185]                   options(future.plan = NULL)
[17:29:45.185]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.185]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:45.185]                 }
[17:29:45.185]                 ...future.workdir <- getwd()
[17:29:45.185]             }
[17:29:45.185]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:45.185]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:45.185]         }
[17:29:45.185]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:45.185]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:45.185]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:45.185]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:45.185]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:45.185]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:45.185]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:45.185]             base::names(...future.oldOptions))
[17:29:45.185]     }
[17:29:45.185]     if (FALSE) {
[17:29:45.185]     }
[17:29:45.185]     else {
[17:29:45.185]         if (TRUE) {
[17:29:45.185]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:45.185]                 open = "w")
[17:29:45.185]         }
[17:29:45.185]         else {
[17:29:45.185]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:45.185]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:45.185]         }
[17:29:45.185]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:45.185]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:45.185]             base::sink(type = "output", split = FALSE)
[17:29:45.185]             base::close(...future.stdout)
[17:29:45.185]         }, add = TRUE)
[17:29:45.185]     }
[17:29:45.185]     ...future.frame <- base::sys.nframe()
[17:29:45.185]     ...future.conditions <- base::list()
[17:29:45.185]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:45.185]     if (FALSE) {
[17:29:45.185]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:45.185]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:45.185]     }
[17:29:45.185]     ...future.result <- base::tryCatch({
[17:29:45.185]         base::withCallingHandlers({
[17:29:45.185]             ...future.value <- base::withVisible(base::local({
[17:29:45.185]                 ...future.makeSendCondition <- base::local({
[17:29:45.185]                   sendCondition <- NULL
[17:29:45.185]                   function(frame = 1L) {
[17:29:45.185]                     if (is.function(sendCondition)) 
[17:29:45.185]                       return(sendCondition)
[17:29:45.185]                     ns <- getNamespace("parallel")
[17:29:45.185]                     if (exists("sendData", mode = "function", 
[17:29:45.185]                       envir = ns)) {
[17:29:45.185]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:45.185]                         envir = ns)
[17:29:45.185]                       envir <- sys.frame(frame)
[17:29:45.185]                       master <- NULL
[17:29:45.185]                       while (!identical(envir, .GlobalEnv) && 
[17:29:45.185]                         !identical(envir, emptyenv())) {
[17:29:45.185]                         if (exists("master", mode = "list", envir = envir, 
[17:29:45.185]                           inherits = FALSE)) {
[17:29:45.185]                           master <- get("master", mode = "list", 
[17:29:45.185]                             envir = envir, inherits = FALSE)
[17:29:45.185]                           if (inherits(master, c("SOCKnode", 
[17:29:45.185]                             "SOCK0node"))) {
[17:29:45.185]                             sendCondition <<- function(cond) {
[17:29:45.185]                               data <- list(type = "VALUE", value = cond, 
[17:29:45.185]                                 success = TRUE)
[17:29:45.185]                               parallel_sendData(master, data)
[17:29:45.185]                             }
[17:29:45.185]                             return(sendCondition)
[17:29:45.185]                           }
[17:29:45.185]                         }
[17:29:45.185]                         frame <- frame + 1L
[17:29:45.185]                         envir <- sys.frame(frame)
[17:29:45.185]                       }
[17:29:45.185]                     }
[17:29:45.185]                     sendCondition <<- function(cond) NULL
[17:29:45.185]                   }
[17:29:45.185]                 })
[17:29:45.185]                 withCallingHandlers({
[17:29:45.185]                   {
[17:29:45.185]                     sample(x, size = 1L)
[17:29:45.185]                   }
[17:29:45.185]                 }, immediateCondition = function(cond) {
[17:29:45.185]                   sendCondition <- ...future.makeSendCondition()
[17:29:45.185]                   sendCondition(cond)
[17:29:45.185]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.185]                   {
[17:29:45.185]                     inherits <- base::inherits
[17:29:45.185]                     invokeRestart <- base::invokeRestart
[17:29:45.185]                     is.null <- base::is.null
[17:29:45.185]                     muffled <- FALSE
[17:29:45.185]                     if (inherits(cond, "message")) {
[17:29:45.185]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:45.185]                       if (muffled) 
[17:29:45.185]                         invokeRestart("muffleMessage")
[17:29:45.185]                     }
[17:29:45.185]                     else if (inherits(cond, "warning")) {
[17:29:45.185]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:45.185]                       if (muffled) 
[17:29:45.185]                         invokeRestart("muffleWarning")
[17:29:45.185]                     }
[17:29:45.185]                     else if (inherits(cond, "condition")) {
[17:29:45.185]                       if (!is.null(pattern)) {
[17:29:45.185]                         computeRestarts <- base::computeRestarts
[17:29:45.185]                         grepl <- base::grepl
[17:29:45.185]                         restarts <- computeRestarts(cond)
[17:29:45.185]                         for (restart in restarts) {
[17:29:45.185]                           name <- restart$name
[17:29:45.185]                           if (is.null(name)) 
[17:29:45.185]                             next
[17:29:45.185]                           if (!grepl(pattern, name)) 
[17:29:45.185]                             next
[17:29:45.185]                           invokeRestart(restart)
[17:29:45.185]                           muffled <- TRUE
[17:29:45.185]                           break
[17:29:45.185]                         }
[17:29:45.185]                       }
[17:29:45.185]                     }
[17:29:45.185]                     invisible(muffled)
[17:29:45.185]                   }
[17:29:45.185]                   muffleCondition(cond)
[17:29:45.185]                 })
[17:29:45.185]             }))
[17:29:45.185]             future::FutureResult(value = ...future.value$value, 
[17:29:45.185]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.185]                   ...future.rng), globalenv = if (FALSE) 
[17:29:45.185]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:45.185]                     ...future.globalenv.names))
[17:29:45.185]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:45.185]         }, condition = base::local({
[17:29:45.185]             c <- base::c
[17:29:45.185]             inherits <- base::inherits
[17:29:45.185]             invokeRestart <- base::invokeRestart
[17:29:45.185]             length <- base::length
[17:29:45.185]             list <- base::list
[17:29:45.185]             seq.int <- base::seq.int
[17:29:45.185]             signalCondition <- base::signalCondition
[17:29:45.185]             sys.calls <- base::sys.calls
[17:29:45.185]             `[[` <- base::`[[`
[17:29:45.185]             `+` <- base::`+`
[17:29:45.185]             `<<-` <- base::`<<-`
[17:29:45.185]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:45.185]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:45.185]                   3L)]
[17:29:45.185]             }
[17:29:45.185]             function(cond) {
[17:29:45.185]                 is_error <- inherits(cond, "error")
[17:29:45.185]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:45.185]                   NULL)
[17:29:45.185]                 if (is_error) {
[17:29:45.185]                   sessionInformation <- function() {
[17:29:45.185]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:45.185]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:45.185]                       search = base::search(), system = base::Sys.info())
[17:29:45.185]                   }
[17:29:45.185]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.185]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:45.185]                     cond$call), session = sessionInformation(), 
[17:29:45.185]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:45.185]                   signalCondition(cond)
[17:29:45.185]                 }
[17:29:45.185]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:45.185]                 "immediateCondition"))) {
[17:29:45.185]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:45.185]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.185]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:45.185]                   if (TRUE && !signal) {
[17:29:45.185]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.185]                     {
[17:29:45.185]                       inherits <- base::inherits
[17:29:45.185]                       invokeRestart <- base::invokeRestart
[17:29:45.185]                       is.null <- base::is.null
[17:29:45.185]                       muffled <- FALSE
[17:29:45.185]                       if (inherits(cond, "message")) {
[17:29:45.185]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.185]                         if (muffled) 
[17:29:45.185]                           invokeRestart("muffleMessage")
[17:29:45.185]                       }
[17:29:45.185]                       else if (inherits(cond, "warning")) {
[17:29:45.185]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.185]                         if (muffled) 
[17:29:45.185]                           invokeRestart("muffleWarning")
[17:29:45.185]                       }
[17:29:45.185]                       else if (inherits(cond, "condition")) {
[17:29:45.185]                         if (!is.null(pattern)) {
[17:29:45.185]                           computeRestarts <- base::computeRestarts
[17:29:45.185]                           grepl <- base::grepl
[17:29:45.185]                           restarts <- computeRestarts(cond)
[17:29:45.185]                           for (restart in restarts) {
[17:29:45.185]                             name <- restart$name
[17:29:45.185]                             if (is.null(name)) 
[17:29:45.185]                               next
[17:29:45.185]                             if (!grepl(pattern, name)) 
[17:29:45.185]                               next
[17:29:45.185]                             invokeRestart(restart)
[17:29:45.185]                             muffled <- TRUE
[17:29:45.185]                             break
[17:29:45.185]                           }
[17:29:45.185]                         }
[17:29:45.185]                       }
[17:29:45.185]                       invisible(muffled)
[17:29:45.185]                     }
[17:29:45.185]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.185]                   }
[17:29:45.185]                 }
[17:29:45.185]                 else {
[17:29:45.185]                   if (TRUE) {
[17:29:45.185]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.185]                     {
[17:29:45.185]                       inherits <- base::inherits
[17:29:45.185]                       invokeRestart <- base::invokeRestart
[17:29:45.185]                       is.null <- base::is.null
[17:29:45.185]                       muffled <- FALSE
[17:29:45.185]                       if (inherits(cond, "message")) {
[17:29:45.185]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.185]                         if (muffled) 
[17:29:45.185]                           invokeRestart("muffleMessage")
[17:29:45.185]                       }
[17:29:45.185]                       else if (inherits(cond, "warning")) {
[17:29:45.185]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.185]                         if (muffled) 
[17:29:45.185]                           invokeRestart("muffleWarning")
[17:29:45.185]                       }
[17:29:45.185]                       else if (inherits(cond, "condition")) {
[17:29:45.185]                         if (!is.null(pattern)) {
[17:29:45.185]                           computeRestarts <- base::computeRestarts
[17:29:45.185]                           grepl <- base::grepl
[17:29:45.185]                           restarts <- computeRestarts(cond)
[17:29:45.185]                           for (restart in restarts) {
[17:29:45.185]                             name <- restart$name
[17:29:45.185]                             if (is.null(name)) 
[17:29:45.185]                               next
[17:29:45.185]                             if (!grepl(pattern, name)) 
[17:29:45.185]                               next
[17:29:45.185]                             invokeRestart(restart)
[17:29:45.185]                             muffled <- TRUE
[17:29:45.185]                             break
[17:29:45.185]                           }
[17:29:45.185]                         }
[17:29:45.185]                       }
[17:29:45.185]                       invisible(muffled)
[17:29:45.185]                     }
[17:29:45.185]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.185]                   }
[17:29:45.185]                 }
[17:29:45.185]             }
[17:29:45.185]         }))
[17:29:45.185]     }, error = function(ex) {
[17:29:45.185]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:45.185]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.185]                 ...future.rng), started = ...future.startTime, 
[17:29:45.185]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:45.185]             version = "1.8"), class = "FutureResult")
[17:29:45.185]     }, finally = {
[17:29:45.185]         if (!identical(...future.workdir, getwd())) 
[17:29:45.185]             setwd(...future.workdir)
[17:29:45.185]         {
[17:29:45.185]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:45.185]                 ...future.oldOptions$nwarnings <- NULL
[17:29:45.185]             }
[17:29:45.185]             base::options(...future.oldOptions)
[17:29:45.185]             if (.Platform$OS.type == "windows") {
[17:29:45.185]                 old_names <- names(...future.oldEnvVars)
[17:29:45.185]                 envs <- base::Sys.getenv()
[17:29:45.185]                 names <- names(envs)
[17:29:45.185]                 common <- intersect(names, old_names)
[17:29:45.185]                 added <- setdiff(names, old_names)
[17:29:45.185]                 removed <- setdiff(old_names, names)
[17:29:45.185]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:45.185]                   envs[common]]
[17:29:45.185]                 NAMES <- toupper(changed)
[17:29:45.185]                 args <- list()
[17:29:45.185]                 for (kk in seq_along(NAMES)) {
[17:29:45.185]                   name <- changed[[kk]]
[17:29:45.185]                   NAME <- NAMES[[kk]]
[17:29:45.185]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.185]                     next
[17:29:45.185]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.185]                 }
[17:29:45.185]                 NAMES <- toupper(added)
[17:29:45.185]                 for (kk in seq_along(NAMES)) {
[17:29:45.185]                   name <- added[[kk]]
[17:29:45.185]                   NAME <- NAMES[[kk]]
[17:29:45.185]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.185]                     next
[17:29:45.185]                   args[[name]] <- ""
[17:29:45.185]                 }
[17:29:45.185]                 NAMES <- toupper(removed)
[17:29:45.185]                 for (kk in seq_along(NAMES)) {
[17:29:45.185]                   name <- removed[[kk]]
[17:29:45.185]                   NAME <- NAMES[[kk]]
[17:29:45.185]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.185]                     next
[17:29:45.185]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.185]                 }
[17:29:45.185]                 if (length(args) > 0) 
[17:29:45.185]                   base::do.call(base::Sys.setenv, args = args)
[17:29:45.185]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:45.185]             }
[17:29:45.185]             else {
[17:29:45.185]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:45.185]             }
[17:29:45.185]             {
[17:29:45.185]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:45.185]                   0L) {
[17:29:45.185]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:45.185]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:45.185]                   base::options(opts)
[17:29:45.185]                 }
[17:29:45.185]                 {
[17:29:45.185]                   {
[17:29:45.185]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:45.185]                     NULL
[17:29:45.185]                   }
[17:29:45.185]                   options(future.plan = NULL)
[17:29:45.185]                   if (is.na(NA_character_)) 
[17:29:45.185]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.185]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:45.185]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:45.185]                     .init = FALSE)
[17:29:45.185]                 }
[17:29:45.185]             }
[17:29:45.185]         }
[17:29:45.185]     })
[17:29:45.185]     if (TRUE) {
[17:29:45.185]         base::sink(type = "output", split = FALSE)
[17:29:45.185]         if (TRUE) {
[17:29:45.185]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:45.185]         }
[17:29:45.185]         else {
[17:29:45.185]             ...future.result["stdout"] <- base::list(NULL)
[17:29:45.185]         }
[17:29:45.185]         base::close(...future.stdout)
[17:29:45.185]         ...future.stdout <- NULL
[17:29:45.185]     }
[17:29:45.185]     ...future.result$conditions <- ...future.conditions
[17:29:45.185]     ...future.result$finished <- base::Sys.time()
[17:29:45.185]     ...future.result
[17:29:45.185] }
[17:29:45.193] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:45.193] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:45.194] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:45.194] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:45.195] MultisessionFuture started
[17:29:45.196] - Launch lazy future ... done
[17:29:45.196] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_4-298883'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001adda363ca8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:29:45.215] receiveMessageFromWorker() for ClusterFuture ...
[17:29:45.216] - Validating connection of MultisessionFuture
[17:29:45.216] - received message: FutureResult
[17:29:45.216] - Received FutureResult
[17:29:45.217] - Erased future from FutureRegistry
[17:29:45.217] result() for ClusterFuture ...
[17:29:45.217] - result already collected: FutureResult
[17:29:45.217] result() for ClusterFuture ... done
[17:29:45.217] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.217] resolve() on list ...
[17:29:45.218]  recursive: 0
[17:29:45.218]  length: 4
[17:29:45.218] 
[17:29:45.218] Future #1
[17:29:45.218] result() for ClusterFuture ...
[17:29:45.218] - result already collected: FutureResult
[17:29:45.219] result() for ClusterFuture ... done
[17:29:45.219] result() for ClusterFuture ...
[17:29:45.219] - result already collected: FutureResult
[17:29:45.219] result() for ClusterFuture ... done
[17:29:45.219] signalConditionsASAP(MultisessionFuture, pos=1) ...
[17:29:45.219] - nx: 4
[17:29:45.220] - relay: TRUE
[17:29:45.220] - stdout: TRUE
[17:29:45.220] - signal: TRUE
[17:29:45.220] - resignal: FALSE
[17:29:45.220] - force: TRUE
[17:29:45.220] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:45.220] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:45.221]  - until=1
[17:29:45.221]  - relaying element #1
[17:29:45.221] result() for ClusterFuture ...
[17:29:45.221] - result already collected: FutureResult
[17:29:45.221] result() for ClusterFuture ... done
[17:29:45.221] result() for ClusterFuture ...
[17:29:45.222] - result already collected: FutureResult
[17:29:45.222] result() for ClusterFuture ... done
[17:29:45.222] result() for ClusterFuture ...
[17:29:45.222] - result already collected: FutureResult
[17:29:45.222] result() for ClusterFuture ... done
[17:29:45.223] result() for ClusterFuture ...
[17:29:45.223] - result already collected: FutureResult
[17:29:45.223] result() for ClusterFuture ... done
[17:29:45.223] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:45.224] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:45.224] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[17:29:45.224]  length: 3 (resolved future 1)
[17:29:45.224] Future #2
[17:29:45.225] result() for ClusterFuture ...
[17:29:45.225] - result already collected: FutureResult
[17:29:45.225] result() for ClusterFuture ... done
[17:29:45.225] result() for ClusterFuture ...
[17:29:45.226] - result already collected: FutureResult
[17:29:45.226] result() for ClusterFuture ... done
[17:29:45.226] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:29:45.227] - nx: 4
[17:29:45.227] - relay: TRUE
[17:29:45.227] - stdout: TRUE
[17:29:45.227] - signal: TRUE
[17:29:45.228] - resignal: FALSE
[17:29:45.228] - force: TRUE
[17:29:45.228] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:45.228] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:45.229]  - until=2
[17:29:45.229]  - relaying element #2
[17:29:45.229] result() for ClusterFuture ...
[17:29:45.230] - result already collected: FutureResult
[17:29:45.230] result() for ClusterFuture ... done
[17:29:45.230] result() for ClusterFuture ...
[17:29:45.230] - result already collected: FutureResult
[17:29:45.231] result() for ClusterFuture ... done
[17:29:45.231] result() for ClusterFuture ...
[17:29:45.231] - result already collected: FutureResult
[17:29:45.232] result() for ClusterFuture ... done
[17:29:45.232] result() for ClusterFuture ...
[17:29:45.232] - result already collected: FutureResult
[17:29:45.232] result() for ClusterFuture ... done
[17:29:45.233] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:45.233] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:45.233] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:29:45.233]  length: 2 (resolved future 2)
[17:29:45.234] Future #3
[17:29:45.234] result() for ClusterFuture ...
[17:29:45.234] - result already collected: FutureResult
[17:29:45.234] result() for ClusterFuture ... done
[17:29:45.235] result() for ClusterFuture ...
[17:29:45.235] - result already collected: FutureResult
[17:29:45.235] result() for ClusterFuture ... done
[17:29:45.236] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:29:45.236] - nx: 4
[17:29:45.236] - relay: TRUE
[17:29:45.236] - stdout: TRUE
[17:29:45.237] - signal: TRUE
[17:29:45.237] - resignal: FALSE
[17:29:45.237] - force: TRUE
[17:29:45.237] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:45.238] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:45.238]  - until=3
[17:29:45.238]  - relaying element #3
[17:29:45.238] result() for ClusterFuture ...
[17:29:45.239] - result already collected: FutureResult
[17:29:45.239] result() for ClusterFuture ... done
[17:29:45.239] result() for ClusterFuture ...
[17:29:45.240] - result already collected: FutureResult
[17:29:45.240] result() for ClusterFuture ... done
[17:29:45.240] result() for ClusterFuture ...
[17:29:45.240] - result already collected: FutureResult
[17:29:45.241] result() for ClusterFuture ... done
[17:29:45.241] result() for ClusterFuture ...
[17:29:45.241] - result already collected: FutureResult
[17:29:45.241] result() for ClusterFuture ... done
[17:29:45.242] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:45.242] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:45.242] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:29:45.243]  length: 1 (resolved future 3)
[17:29:45.243] Future #4
[17:29:45.243] result() for ClusterFuture ...
[17:29:45.243] - result already collected: FutureResult
[17:29:45.244] result() for ClusterFuture ... done
[17:29:45.244] result() for ClusterFuture ...
[17:29:45.244] - result already collected: FutureResult
[17:29:45.244] result() for ClusterFuture ... done
[17:29:45.245] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:29:45.245] - nx: 4
[17:29:45.245] - relay: TRUE
[17:29:45.246] - stdout: TRUE
[17:29:45.246] - signal: TRUE
[17:29:45.246] - resignal: FALSE
[17:29:45.246] - force: TRUE
[17:29:45.247] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:45.247] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:45.247]  - until=4
[17:29:45.247]  - relaying element #4
[17:29:45.248] result() for ClusterFuture ...
[17:29:45.248] - result already collected: FutureResult
[17:29:45.248] result() for ClusterFuture ... done
[17:29:45.248] result() for ClusterFuture ...
[17:29:45.248] - result already collected: FutureResult
[17:29:45.249] result() for ClusterFuture ... done
[17:29:45.249] result() for ClusterFuture ...
[17:29:45.249] - result already collected: FutureResult
[17:29:45.249] result() for ClusterFuture ... done
[17:29:45.250] result() for ClusterFuture ...
[17:29:45.250] - result already collected: FutureResult
[17:29:45.250] result() for ClusterFuture ... done
[17:29:45.251] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:45.251] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:45.251] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:29:45.251]  length: 0 (resolved future 4)
[17:29:45.252] Relaying remaining futures
[17:29:45.252] signalConditionsASAP(NULL, pos=0) ...
[17:29:45.252] - nx: 4
[17:29:45.252] - relay: TRUE
[17:29:45.253] - stdout: TRUE
[17:29:45.253] - signal: TRUE
[17:29:45.253] - resignal: FALSE
[17:29:45.253] - force: TRUE
[17:29:45.254] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:45.254] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:29:45.254] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:45.255] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:45.255] signalConditionsASAP(NULL, pos=0) ... done
[17:29:45.255] resolve() on list ... DONE
[17:29:45.255] result() for ClusterFuture ...
[17:29:45.256] - result already collected: FutureResult
[17:29:45.256] result() for ClusterFuture ... done
[17:29:45.256] result() for ClusterFuture ...
[17:29:45.256] - result already collected: FutureResult
[17:29:45.256] result() for ClusterFuture ... done
[17:29:45.257] result() for ClusterFuture ...
[17:29:45.257] - result already collected: FutureResult
[17:29:45.257] result() for ClusterFuture ... done
[17:29:45.257] result() for ClusterFuture ...
[17:29:45.258] - result already collected: FutureResult
[17:29:45.258] result() for ClusterFuture ... done
[17:29:45.258] result() for ClusterFuture ...
[17:29:45.258] - result already collected: FutureResult
[17:29:45.259] result() for ClusterFuture ... done
[17:29:45.259] result() for ClusterFuture ...
[17:29:45.259] - result already collected: FutureResult
[17:29:45.259] result() for ClusterFuture ... done
[17:29:45.260] result() for ClusterFuture ...
[17:29:45.260] - result already collected: FutureResult
[17:29:45.260] result() for ClusterFuture ... done
[17:29:45.260] result() for ClusterFuture ...
[17:29:45.260] - result already collected: FutureResult
[17:29:45.261] result() for ClusterFuture ... done
[[1]]
[1] 2

[[2]]
[1] 1

[[3]]
[1] 2

[[4]]
[1] 0

[17:29:45.261] getGlobalsAndPackages() ...
[17:29:45.262] Searching for globals...
[17:29:45.264] - globals found: [3] '{', 'sample', 'x'
[17:29:45.264] Searching for globals ... DONE
[17:29:45.264] Resolving globals: FALSE
[17:29:45.265] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:45.266] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:45.266] - globals: [1] 'x'
[17:29:45.266] 
[17:29:45.266] getGlobalsAndPackages() ... DONE
[17:29:45.267] run() for 'Future' ...
[17:29:45.267] - state: 'created'
[17:29:45.267] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:45.285] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.286] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:45.286]   - Field: 'node'
[17:29:45.286]   - Field: 'label'
[17:29:45.286]   - Field: 'local'
[17:29:45.287]   - Field: 'owner'
[17:29:45.287]   - Field: 'envir'
[17:29:45.287]   - Field: 'workers'
[17:29:45.287]   - Field: 'packages'
[17:29:45.288]   - Field: 'gc'
[17:29:45.288]   - Field: 'conditions'
[17:29:45.288]   - Field: 'persistent'
[17:29:45.288]   - Field: 'expr'
[17:29:45.289]   - Field: 'uuid'
[17:29:45.289]   - Field: 'seed'
[17:29:45.289]   - Field: 'version'
[17:29:45.289]   - Field: 'result'
[17:29:45.290]   - Field: 'asynchronous'
[17:29:45.290]   - Field: 'calls'
[17:29:45.290]   - Field: 'globals'
[17:29:45.290]   - Field: 'stdout'
[17:29:45.291]   - Field: 'earlySignal'
[17:29:45.291]   - Field: 'lazy'
[17:29:45.291]   - Field: 'state'
[17:29:45.291] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:45.292] - Launch lazy future ...
[17:29:45.292] Packages needed by the future expression (n = 0): <none>
[17:29:45.292] Packages needed by future strategies (n = 0): <none>
[17:29:45.293] {
[17:29:45.293]     {
[17:29:45.293]         {
[17:29:45.293]             ...future.startTime <- base::Sys.time()
[17:29:45.293]             {
[17:29:45.293]                 {
[17:29:45.293]                   {
[17:29:45.293]                     {
[17:29:45.293]                       base::local({
[17:29:45.293]                         has_future <- base::requireNamespace("future", 
[17:29:45.293]                           quietly = TRUE)
[17:29:45.293]                         if (has_future) {
[17:29:45.293]                           ns <- base::getNamespace("future")
[17:29:45.293]                           version <- ns[[".package"]][["version"]]
[17:29:45.293]                           if (is.null(version)) 
[17:29:45.293]                             version <- utils::packageVersion("future")
[17:29:45.293]                         }
[17:29:45.293]                         else {
[17:29:45.293]                           version <- NULL
[17:29:45.293]                         }
[17:29:45.293]                         if (!has_future || version < "1.8.0") {
[17:29:45.293]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:45.293]                             "", base::R.version$version.string), 
[17:29:45.293]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:45.293]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:45.293]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:45.293]                               "release", "version")], collapse = " "), 
[17:29:45.293]                             hostname = base::Sys.info()[["nodename"]])
[17:29:45.293]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:45.293]                             info)
[17:29:45.293]                           info <- base::paste(info, collapse = "; ")
[17:29:45.293]                           if (!has_future) {
[17:29:45.293]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:45.293]                               info)
[17:29:45.293]                           }
[17:29:45.293]                           else {
[17:29:45.293]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:45.293]                               info, version)
[17:29:45.293]                           }
[17:29:45.293]                           base::stop(msg)
[17:29:45.293]                         }
[17:29:45.293]                       })
[17:29:45.293]                     }
[17:29:45.293]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:45.293]                     base::options(mc.cores = 1L)
[17:29:45.293]                   }
[17:29:45.293]                   ...future.strategy.old <- future::plan("list")
[17:29:45.293]                   options(future.plan = NULL)
[17:29:45.293]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.293]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:45.293]                 }
[17:29:45.293]                 ...future.workdir <- getwd()
[17:29:45.293]             }
[17:29:45.293]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:45.293]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:45.293]         }
[17:29:45.293]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:45.293]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:45.293]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:45.293]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:45.293]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:45.293]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:45.293]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:45.293]             base::names(...future.oldOptions))
[17:29:45.293]     }
[17:29:45.293]     if (FALSE) {
[17:29:45.293]     }
[17:29:45.293]     else {
[17:29:45.293]         if (TRUE) {
[17:29:45.293]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:45.293]                 open = "w")
[17:29:45.293]         }
[17:29:45.293]         else {
[17:29:45.293]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:45.293]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:45.293]         }
[17:29:45.293]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:45.293]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:45.293]             base::sink(type = "output", split = FALSE)
[17:29:45.293]             base::close(...future.stdout)
[17:29:45.293]         }, add = TRUE)
[17:29:45.293]     }
[17:29:45.293]     ...future.frame <- base::sys.nframe()
[17:29:45.293]     ...future.conditions <- base::list()
[17:29:45.293]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:45.293]     if (FALSE) {
[17:29:45.293]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:45.293]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:45.293]     }
[17:29:45.293]     ...future.result <- base::tryCatch({
[17:29:45.293]         base::withCallingHandlers({
[17:29:45.293]             ...future.value <- base::withVisible(base::local({
[17:29:45.293]                 ...future.makeSendCondition <- base::local({
[17:29:45.293]                   sendCondition <- NULL
[17:29:45.293]                   function(frame = 1L) {
[17:29:45.293]                     if (is.function(sendCondition)) 
[17:29:45.293]                       return(sendCondition)
[17:29:45.293]                     ns <- getNamespace("parallel")
[17:29:45.293]                     if (exists("sendData", mode = "function", 
[17:29:45.293]                       envir = ns)) {
[17:29:45.293]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:45.293]                         envir = ns)
[17:29:45.293]                       envir <- sys.frame(frame)
[17:29:45.293]                       master <- NULL
[17:29:45.293]                       while (!identical(envir, .GlobalEnv) && 
[17:29:45.293]                         !identical(envir, emptyenv())) {
[17:29:45.293]                         if (exists("master", mode = "list", envir = envir, 
[17:29:45.293]                           inherits = FALSE)) {
[17:29:45.293]                           master <- get("master", mode = "list", 
[17:29:45.293]                             envir = envir, inherits = FALSE)
[17:29:45.293]                           if (inherits(master, c("SOCKnode", 
[17:29:45.293]                             "SOCK0node"))) {
[17:29:45.293]                             sendCondition <<- function(cond) {
[17:29:45.293]                               data <- list(type = "VALUE", value = cond, 
[17:29:45.293]                                 success = TRUE)
[17:29:45.293]                               parallel_sendData(master, data)
[17:29:45.293]                             }
[17:29:45.293]                             return(sendCondition)
[17:29:45.293]                           }
[17:29:45.293]                         }
[17:29:45.293]                         frame <- frame + 1L
[17:29:45.293]                         envir <- sys.frame(frame)
[17:29:45.293]                       }
[17:29:45.293]                     }
[17:29:45.293]                     sendCondition <<- function(cond) NULL
[17:29:45.293]                   }
[17:29:45.293]                 })
[17:29:45.293]                 withCallingHandlers({
[17:29:45.293]                   {
[17:29:45.293]                     sample(x, size = 1L)
[17:29:45.293]                   }
[17:29:45.293]                 }, immediateCondition = function(cond) {
[17:29:45.293]                   sendCondition <- ...future.makeSendCondition()
[17:29:45.293]                   sendCondition(cond)
[17:29:45.293]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.293]                   {
[17:29:45.293]                     inherits <- base::inherits
[17:29:45.293]                     invokeRestart <- base::invokeRestart
[17:29:45.293]                     is.null <- base::is.null
[17:29:45.293]                     muffled <- FALSE
[17:29:45.293]                     if (inherits(cond, "message")) {
[17:29:45.293]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:45.293]                       if (muffled) 
[17:29:45.293]                         invokeRestart("muffleMessage")
[17:29:45.293]                     }
[17:29:45.293]                     else if (inherits(cond, "warning")) {
[17:29:45.293]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:45.293]                       if (muffled) 
[17:29:45.293]                         invokeRestart("muffleWarning")
[17:29:45.293]                     }
[17:29:45.293]                     else if (inherits(cond, "condition")) {
[17:29:45.293]                       if (!is.null(pattern)) {
[17:29:45.293]                         computeRestarts <- base::computeRestarts
[17:29:45.293]                         grepl <- base::grepl
[17:29:45.293]                         restarts <- computeRestarts(cond)
[17:29:45.293]                         for (restart in restarts) {
[17:29:45.293]                           name <- restart$name
[17:29:45.293]                           if (is.null(name)) 
[17:29:45.293]                             next
[17:29:45.293]                           if (!grepl(pattern, name)) 
[17:29:45.293]                             next
[17:29:45.293]                           invokeRestart(restart)
[17:29:45.293]                           muffled <- TRUE
[17:29:45.293]                           break
[17:29:45.293]                         }
[17:29:45.293]                       }
[17:29:45.293]                     }
[17:29:45.293]                     invisible(muffled)
[17:29:45.293]                   }
[17:29:45.293]                   muffleCondition(cond)
[17:29:45.293]                 })
[17:29:45.293]             }))
[17:29:45.293]             future::FutureResult(value = ...future.value$value, 
[17:29:45.293]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.293]                   ...future.rng), globalenv = if (FALSE) 
[17:29:45.293]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:45.293]                     ...future.globalenv.names))
[17:29:45.293]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:45.293]         }, condition = base::local({
[17:29:45.293]             c <- base::c
[17:29:45.293]             inherits <- base::inherits
[17:29:45.293]             invokeRestart <- base::invokeRestart
[17:29:45.293]             length <- base::length
[17:29:45.293]             list <- base::list
[17:29:45.293]             seq.int <- base::seq.int
[17:29:45.293]             signalCondition <- base::signalCondition
[17:29:45.293]             sys.calls <- base::sys.calls
[17:29:45.293]             `[[` <- base::`[[`
[17:29:45.293]             `+` <- base::`+`
[17:29:45.293]             `<<-` <- base::`<<-`
[17:29:45.293]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:45.293]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:45.293]                   3L)]
[17:29:45.293]             }
[17:29:45.293]             function(cond) {
[17:29:45.293]                 is_error <- inherits(cond, "error")
[17:29:45.293]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:45.293]                   NULL)
[17:29:45.293]                 if (is_error) {
[17:29:45.293]                   sessionInformation <- function() {
[17:29:45.293]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:45.293]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:45.293]                       search = base::search(), system = base::Sys.info())
[17:29:45.293]                   }
[17:29:45.293]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.293]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:45.293]                     cond$call), session = sessionInformation(), 
[17:29:45.293]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:45.293]                   signalCondition(cond)
[17:29:45.293]                 }
[17:29:45.293]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:45.293]                 "immediateCondition"))) {
[17:29:45.293]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:45.293]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.293]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:45.293]                   if (TRUE && !signal) {
[17:29:45.293]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.293]                     {
[17:29:45.293]                       inherits <- base::inherits
[17:29:45.293]                       invokeRestart <- base::invokeRestart
[17:29:45.293]                       is.null <- base::is.null
[17:29:45.293]                       muffled <- FALSE
[17:29:45.293]                       if (inherits(cond, "message")) {
[17:29:45.293]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.293]                         if (muffled) 
[17:29:45.293]                           invokeRestart("muffleMessage")
[17:29:45.293]                       }
[17:29:45.293]                       else if (inherits(cond, "warning")) {
[17:29:45.293]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.293]                         if (muffled) 
[17:29:45.293]                           invokeRestart("muffleWarning")
[17:29:45.293]                       }
[17:29:45.293]                       else if (inherits(cond, "condition")) {
[17:29:45.293]                         if (!is.null(pattern)) {
[17:29:45.293]                           computeRestarts <- base::computeRestarts
[17:29:45.293]                           grepl <- base::grepl
[17:29:45.293]                           restarts <- computeRestarts(cond)
[17:29:45.293]                           for (restart in restarts) {
[17:29:45.293]                             name <- restart$name
[17:29:45.293]                             if (is.null(name)) 
[17:29:45.293]                               next
[17:29:45.293]                             if (!grepl(pattern, name)) 
[17:29:45.293]                               next
[17:29:45.293]                             invokeRestart(restart)
[17:29:45.293]                             muffled <- TRUE
[17:29:45.293]                             break
[17:29:45.293]                           }
[17:29:45.293]                         }
[17:29:45.293]                       }
[17:29:45.293]                       invisible(muffled)
[17:29:45.293]                     }
[17:29:45.293]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.293]                   }
[17:29:45.293]                 }
[17:29:45.293]                 else {
[17:29:45.293]                   if (TRUE) {
[17:29:45.293]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.293]                     {
[17:29:45.293]                       inherits <- base::inherits
[17:29:45.293]                       invokeRestart <- base::invokeRestart
[17:29:45.293]                       is.null <- base::is.null
[17:29:45.293]                       muffled <- FALSE
[17:29:45.293]                       if (inherits(cond, "message")) {
[17:29:45.293]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.293]                         if (muffled) 
[17:29:45.293]                           invokeRestart("muffleMessage")
[17:29:45.293]                       }
[17:29:45.293]                       else if (inherits(cond, "warning")) {
[17:29:45.293]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.293]                         if (muffled) 
[17:29:45.293]                           invokeRestart("muffleWarning")
[17:29:45.293]                       }
[17:29:45.293]                       else if (inherits(cond, "condition")) {
[17:29:45.293]                         if (!is.null(pattern)) {
[17:29:45.293]                           computeRestarts <- base::computeRestarts
[17:29:45.293]                           grepl <- base::grepl
[17:29:45.293]                           restarts <- computeRestarts(cond)
[17:29:45.293]                           for (restart in restarts) {
[17:29:45.293]                             name <- restart$name
[17:29:45.293]                             if (is.null(name)) 
[17:29:45.293]                               next
[17:29:45.293]                             if (!grepl(pattern, name)) 
[17:29:45.293]                               next
[17:29:45.293]                             invokeRestart(restart)
[17:29:45.293]                             muffled <- TRUE
[17:29:45.293]                             break
[17:29:45.293]                           }
[17:29:45.293]                         }
[17:29:45.293]                       }
[17:29:45.293]                       invisible(muffled)
[17:29:45.293]                     }
[17:29:45.293]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.293]                   }
[17:29:45.293]                 }
[17:29:45.293]             }
[17:29:45.293]         }))
[17:29:45.293]     }, error = function(ex) {
[17:29:45.293]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:45.293]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.293]                 ...future.rng), started = ...future.startTime, 
[17:29:45.293]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:45.293]             version = "1.8"), class = "FutureResult")
[17:29:45.293]     }, finally = {
[17:29:45.293]         if (!identical(...future.workdir, getwd())) 
[17:29:45.293]             setwd(...future.workdir)
[17:29:45.293]         {
[17:29:45.293]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:45.293]                 ...future.oldOptions$nwarnings <- NULL
[17:29:45.293]             }
[17:29:45.293]             base::options(...future.oldOptions)
[17:29:45.293]             if (.Platform$OS.type == "windows") {
[17:29:45.293]                 old_names <- names(...future.oldEnvVars)
[17:29:45.293]                 envs <- base::Sys.getenv()
[17:29:45.293]                 names <- names(envs)
[17:29:45.293]                 common <- intersect(names, old_names)
[17:29:45.293]                 added <- setdiff(names, old_names)
[17:29:45.293]                 removed <- setdiff(old_names, names)
[17:29:45.293]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:45.293]                   envs[common]]
[17:29:45.293]                 NAMES <- toupper(changed)
[17:29:45.293]                 args <- list()
[17:29:45.293]                 for (kk in seq_along(NAMES)) {
[17:29:45.293]                   name <- changed[[kk]]
[17:29:45.293]                   NAME <- NAMES[[kk]]
[17:29:45.293]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.293]                     next
[17:29:45.293]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.293]                 }
[17:29:45.293]                 NAMES <- toupper(added)
[17:29:45.293]                 for (kk in seq_along(NAMES)) {
[17:29:45.293]                   name <- added[[kk]]
[17:29:45.293]                   NAME <- NAMES[[kk]]
[17:29:45.293]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.293]                     next
[17:29:45.293]                   args[[name]] <- ""
[17:29:45.293]                 }
[17:29:45.293]                 NAMES <- toupper(removed)
[17:29:45.293]                 for (kk in seq_along(NAMES)) {
[17:29:45.293]                   name <- removed[[kk]]
[17:29:45.293]                   NAME <- NAMES[[kk]]
[17:29:45.293]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.293]                     next
[17:29:45.293]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.293]                 }
[17:29:45.293]                 if (length(args) > 0) 
[17:29:45.293]                   base::do.call(base::Sys.setenv, args = args)
[17:29:45.293]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:45.293]             }
[17:29:45.293]             else {
[17:29:45.293]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:45.293]             }
[17:29:45.293]             {
[17:29:45.293]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:45.293]                   0L) {
[17:29:45.293]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:45.293]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:45.293]                   base::options(opts)
[17:29:45.293]                 }
[17:29:45.293]                 {
[17:29:45.293]                   {
[17:29:45.293]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:45.293]                     NULL
[17:29:45.293]                   }
[17:29:45.293]                   options(future.plan = NULL)
[17:29:45.293]                   if (is.na(NA_character_)) 
[17:29:45.293]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.293]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:45.293]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:45.293]                     .init = FALSE)
[17:29:45.293]                 }
[17:29:45.293]             }
[17:29:45.293]         }
[17:29:45.293]     })
[17:29:45.293]     if (TRUE) {
[17:29:45.293]         base::sink(type = "output", split = FALSE)
[17:29:45.293]         if (TRUE) {
[17:29:45.293]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:45.293]         }
[17:29:45.293]         else {
[17:29:45.293]             ...future.result["stdout"] <- base::list(NULL)
[17:29:45.293]         }
[17:29:45.293]         base::close(...future.stdout)
[17:29:45.293]         ...future.stdout <- NULL
[17:29:45.293]     }
[17:29:45.293]     ...future.result$conditions <- ...future.conditions
[17:29:45.293]     ...future.result$finished <- base::Sys.time()
[17:29:45.293]     ...future.result
[17:29:45.293] }
[17:29:45.301] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:45.301] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:45.302] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:45.302] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:45.303] MultisessionFuture started
[17:29:45.303] - Launch lazy future ... done
[17:29:45.304] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_1-557275'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001adda74ad48
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:29:45.325] receiveMessageFromWorker() for ClusterFuture ...
[17:29:45.325] - Validating connection of MultisessionFuture
[17:29:45.326] - received message: FutureResult
[17:29:45.326] - Received FutureResult
[17:29:45.327] - Erased future from FutureRegistry
[17:29:45.327] result() for ClusterFuture ...
[17:29:45.327] - result already collected: FutureResult
[17:29:45.328] result() for ClusterFuture ... done
[17:29:45.328] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.329] getGlobalsAndPackages() ...
[17:29:45.329] Searching for globals...
[17:29:45.331] - globals found: [3] '{', 'sample', 'x'
[17:29:45.331] Searching for globals ... DONE
[17:29:45.331] Resolving globals: FALSE
[17:29:45.332] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:45.333] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:45.333] - globals: [1] 'x'
[17:29:45.334] 
[17:29:45.334] getGlobalsAndPackages() ... DONE
[17:29:45.334] run() for 'Future' ...
[17:29:45.335] - state: 'created'
[17:29:45.335] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:45.350] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.351] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:45.351]   - Field: 'node'
[17:29:45.352]   - Field: 'label'
[17:29:45.352]   - Field: 'local'
[17:29:45.352]   - Field: 'owner'
[17:29:45.352]   - Field: 'envir'
[17:29:45.353]   - Field: 'workers'
[17:29:45.353]   - Field: 'packages'
[17:29:45.353]   - Field: 'gc'
[17:29:45.354]   - Field: 'conditions'
[17:29:45.354]   - Field: 'persistent'
[17:29:45.354]   - Field: 'expr'
[17:29:45.354]   - Field: 'uuid'
[17:29:45.355]   - Field: 'seed'
[17:29:45.355]   - Field: 'version'
[17:29:45.355]   - Field: 'result'
[17:29:45.356]   - Field: 'asynchronous'
[17:29:45.356]   - Field: 'calls'
[17:29:45.356]   - Field: 'globals'
[17:29:45.357]   - Field: 'stdout'
[17:29:45.357]   - Field: 'earlySignal'
[17:29:45.357]   - Field: 'lazy'
[17:29:45.357]   - Field: 'state'
[17:29:45.358] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:45.358] - Launch lazy future ...
[17:29:45.358] Packages needed by the future expression (n = 0): <none>
[17:29:45.359] Packages needed by future strategies (n = 0): <none>
[17:29:45.359] {
[17:29:45.359]     {
[17:29:45.359]         {
[17:29:45.359]             ...future.startTime <- base::Sys.time()
[17:29:45.359]             {
[17:29:45.359]                 {
[17:29:45.359]                   {
[17:29:45.359]                     {
[17:29:45.359]                       base::local({
[17:29:45.359]                         has_future <- base::requireNamespace("future", 
[17:29:45.359]                           quietly = TRUE)
[17:29:45.359]                         if (has_future) {
[17:29:45.359]                           ns <- base::getNamespace("future")
[17:29:45.359]                           version <- ns[[".package"]][["version"]]
[17:29:45.359]                           if (is.null(version)) 
[17:29:45.359]                             version <- utils::packageVersion("future")
[17:29:45.359]                         }
[17:29:45.359]                         else {
[17:29:45.359]                           version <- NULL
[17:29:45.359]                         }
[17:29:45.359]                         if (!has_future || version < "1.8.0") {
[17:29:45.359]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:45.359]                             "", base::R.version$version.string), 
[17:29:45.359]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:45.359]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:45.359]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:45.359]                               "release", "version")], collapse = " "), 
[17:29:45.359]                             hostname = base::Sys.info()[["nodename"]])
[17:29:45.359]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:45.359]                             info)
[17:29:45.359]                           info <- base::paste(info, collapse = "; ")
[17:29:45.359]                           if (!has_future) {
[17:29:45.359]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:45.359]                               info)
[17:29:45.359]                           }
[17:29:45.359]                           else {
[17:29:45.359]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:45.359]                               info, version)
[17:29:45.359]                           }
[17:29:45.359]                           base::stop(msg)
[17:29:45.359]                         }
[17:29:45.359]                       })
[17:29:45.359]                     }
[17:29:45.359]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:45.359]                     base::options(mc.cores = 1L)
[17:29:45.359]                   }
[17:29:45.359]                   ...future.strategy.old <- future::plan("list")
[17:29:45.359]                   options(future.plan = NULL)
[17:29:45.359]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.359]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:45.359]                 }
[17:29:45.359]                 ...future.workdir <- getwd()
[17:29:45.359]             }
[17:29:45.359]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:45.359]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:45.359]         }
[17:29:45.359]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:45.359]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:45.359]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:45.359]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:45.359]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:45.359]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:45.359]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:45.359]             base::names(...future.oldOptions))
[17:29:45.359]     }
[17:29:45.359]     if (FALSE) {
[17:29:45.359]     }
[17:29:45.359]     else {
[17:29:45.359]         if (TRUE) {
[17:29:45.359]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:45.359]                 open = "w")
[17:29:45.359]         }
[17:29:45.359]         else {
[17:29:45.359]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:45.359]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:45.359]         }
[17:29:45.359]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:45.359]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:45.359]             base::sink(type = "output", split = FALSE)
[17:29:45.359]             base::close(...future.stdout)
[17:29:45.359]         }, add = TRUE)
[17:29:45.359]     }
[17:29:45.359]     ...future.frame <- base::sys.nframe()
[17:29:45.359]     ...future.conditions <- base::list()
[17:29:45.359]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:45.359]     if (FALSE) {
[17:29:45.359]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:45.359]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:45.359]     }
[17:29:45.359]     ...future.result <- base::tryCatch({
[17:29:45.359]         base::withCallingHandlers({
[17:29:45.359]             ...future.value <- base::withVisible(base::local({
[17:29:45.359]                 ...future.makeSendCondition <- base::local({
[17:29:45.359]                   sendCondition <- NULL
[17:29:45.359]                   function(frame = 1L) {
[17:29:45.359]                     if (is.function(sendCondition)) 
[17:29:45.359]                       return(sendCondition)
[17:29:45.359]                     ns <- getNamespace("parallel")
[17:29:45.359]                     if (exists("sendData", mode = "function", 
[17:29:45.359]                       envir = ns)) {
[17:29:45.359]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:45.359]                         envir = ns)
[17:29:45.359]                       envir <- sys.frame(frame)
[17:29:45.359]                       master <- NULL
[17:29:45.359]                       while (!identical(envir, .GlobalEnv) && 
[17:29:45.359]                         !identical(envir, emptyenv())) {
[17:29:45.359]                         if (exists("master", mode = "list", envir = envir, 
[17:29:45.359]                           inherits = FALSE)) {
[17:29:45.359]                           master <- get("master", mode = "list", 
[17:29:45.359]                             envir = envir, inherits = FALSE)
[17:29:45.359]                           if (inherits(master, c("SOCKnode", 
[17:29:45.359]                             "SOCK0node"))) {
[17:29:45.359]                             sendCondition <<- function(cond) {
[17:29:45.359]                               data <- list(type = "VALUE", value = cond, 
[17:29:45.359]                                 success = TRUE)
[17:29:45.359]                               parallel_sendData(master, data)
[17:29:45.359]                             }
[17:29:45.359]                             return(sendCondition)
[17:29:45.359]                           }
[17:29:45.359]                         }
[17:29:45.359]                         frame <- frame + 1L
[17:29:45.359]                         envir <- sys.frame(frame)
[17:29:45.359]                       }
[17:29:45.359]                     }
[17:29:45.359]                     sendCondition <<- function(cond) NULL
[17:29:45.359]                   }
[17:29:45.359]                 })
[17:29:45.359]                 withCallingHandlers({
[17:29:45.359]                   {
[17:29:45.359]                     sample(x, size = 1L)
[17:29:45.359]                   }
[17:29:45.359]                 }, immediateCondition = function(cond) {
[17:29:45.359]                   sendCondition <- ...future.makeSendCondition()
[17:29:45.359]                   sendCondition(cond)
[17:29:45.359]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.359]                   {
[17:29:45.359]                     inherits <- base::inherits
[17:29:45.359]                     invokeRestart <- base::invokeRestart
[17:29:45.359]                     is.null <- base::is.null
[17:29:45.359]                     muffled <- FALSE
[17:29:45.359]                     if (inherits(cond, "message")) {
[17:29:45.359]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:45.359]                       if (muffled) 
[17:29:45.359]                         invokeRestart("muffleMessage")
[17:29:45.359]                     }
[17:29:45.359]                     else if (inherits(cond, "warning")) {
[17:29:45.359]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:45.359]                       if (muffled) 
[17:29:45.359]                         invokeRestart("muffleWarning")
[17:29:45.359]                     }
[17:29:45.359]                     else if (inherits(cond, "condition")) {
[17:29:45.359]                       if (!is.null(pattern)) {
[17:29:45.359]                         computeRestarts <- base::computeRestarts
[17:29:45.359]                         grepl <- base::grepl
[17:29:45.359]                         restarts <- computeRestarts(cond)
[17:29:45.359]                         for (restart in restarts) {
[17:29:45.359]                           name <- restart$name
[17:29:45.359]                           if (is.null(name)) 
[17:29:45.359]                             next
[17:29:45.359]                           if (!grepl(pattern, name)) 
[17:29:45.359]                             next
[17:29:45.359]                           invokeRestart(restart)
[17:29:45.359]                           muffled <- TRUE
[17:29:45.359]                           break
[17:29:45.359]                         }
[17:29:45.359]                       }
[17:29:45.359]                     }
[17:29:45.359]                     invisible(muffled)
[17:29:45.359]                   }
[17:29:45.359]                   muffleCondition(cond)
[17:29:45.359]                 })
[17:29:45.359]             }))
[17:29:45.359]             future::FutureResult(value = ...future.value$value, 
[17:29:45.359]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.359]                   ...future.rng), globalenv = if (FALSE) 
[17:29:45.359]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:45.359]                     ...future.globalenv.names))
[17:29:45.359]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:45.359]         }, condition = base::local({
[17:29:45.359]             c <- base::c
[17:29:45.359]             inherits <- base::inherits
[17:29:45.359]             invokeRestart <- base::invokeRestart
[17:29:45.359]             length <- base::length
[17:29:45.359]             list <- base::list
[17:29:45.359]             seq.int <- base::seq.int
[17:29:45.359]             signalCondition <- base::signalCondition
[17:29:45.359]             sys.calls <- base::sys.calls
[17:29:45.359]             `[[` <- base::`[[`
[17:29:45.359]             `+` <- base::`+`
[17:29:45.359]             `<<-` <- base::`<<-`
[17:29:45.359]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:45.359]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:45.359]                   3L)]
[17:29:45.359]             }
[17:29:45.359]             function(cond) {
[17:29:45.359]                 is_error <- inherits(cond, "error")
[17:29:45.359]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:45.359]                   NULL)
[17:29:45.359]                 if (is_error) {
[17:29:45.359]                   sessionInformation <- function() {
[17:29:45.359]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:45.359]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:45.359]                       search = base::search(), system = base::Sys.info())
[17:29:45.359]                   }
[17:29:45.359]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.359]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:45.359]                     cond$call), session = sessionInformation(), 
[17:29:45.359]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:45.359]                   signalCondition(cond)
[17:29:45.359]                 }
[17:29:45.359]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:45.359]                 "immediateCondition"))) {
[17:29:45.359]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:45.359]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.359]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:45.359]                   if (TRUE && !signal) {
[17:29:45.359]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.359]                     {
[17:29:45.359]                       inherits <- base::inherits
[17:29:45.359]                       invokeRestart <- base::invokeRestart
[17:29:45.359]                       is.null <- base::is.null
[17:29:45.359]                       muffled <- FALSE
[17:29:45.359]                       if (inherits(cond, "message")) {
[17:29:45.359]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.359]                         if (muffled) 
[17:29:45.359]                           invokeRestart("muffleMessage")
[17:29:45.359]                       }
[17:29:45.359]                       else if (inherits(cond, "warning")) {
[17:29:45.359]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.359]                         if (muffled) 
[17:29:45.359]                           invokeRestart("muffleWarning")
[17:29:45.359]                       }
[17:29:45.359]                       else if (inherits(cond, "condition")) {
[17:29:45.359]                         if (!is.null(pattern)) {
[17:29:45.359]                           computeRestarts <- base::computeRestarts
[17:29:45.359]                           grepl <- base::grepl
[17:29:45.359]                           restarts <- computeRestarts(cond)
[17:29:45.359]                           for (restart in restarts) {
[17:29:45.359]                             name <- restart$name
[17:29:45.359]                             if (is.null(name)) 
[17:29:45.359]                               next
[17:29:45.359]                             if (!grepl(pattern, name)) 
[17:29:45.359]                               next
[17:29:45.359]                             invokeRestart(restart)
[17:29:45.359]                             muffled <- TRUE
[17:29:45.359]                             break
[17:29:45.359]                           }
[17:29:45.359]                         }
[17:29:45.359]                       }
[17:29:45.359]                       invisible(muffled)
[17:29:45.359]                     }
[17:29:45.359]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.359]                   }
[17:29:45.359]                 }
[17:29:45.359]                 else {
[17:29:45.359]                   if (TRUE) {
[17:29:45.359]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.359]                     {
[17:29:45.359]                       inherits <- base::inherits
[17:29:45.359]                       invokeRestart <- base::invokeRestart
[17:29:45.359]                       is.null <- base::is.null
[17:29:45.359]                       muffled <- FALSE
[17:29:45.359]                       if (inherits(cond, "message")) {
[17:29:45.359]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.359]                         if (muffled) 
[17:29:45.359]                           invokeRestart("muffleMessage")
[17:29:45.359]                       }
[17:29:45.359]                       else if (inherits(cond, "warning")) {
[17:29:45.359]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.359]                         if (muffled) 
[17:29:45.359]                           invokeRestart("muffleWarning")
[17:29:45.359]                       }
[17:29:45.359]                       else if (inherits(cond, "condition")) {
[17:29:45.359]                         if (!is.null(pattern)) {
[17:29:45.359]                           computeRestarts <- base::computeRestarts
[17:29:45.359]                           grepl <- base::grepl
[17:29:45.359]                           restarts <- computeRestarts(cond)
[17:29:45.359]                           for (restart in restarts) {
[17:29:45.359]                             name <- restart$name
[17:29:45.359]                             if (is.null(name)) 
[17:29:45.359]                               next
[17:29:45.359]                             if (!grepl(pattern, name)) 
[17:29:45.359]                               next
[17:29:45.359]                             invokeRestart(restart)
[17:29:45.359]                             muffled <- TRUE
[17:29:45.359]                             break
[17:29:45.359]                           }
[17:29:45.359]                         }
[17:29:45.359]                       }
[17:29:45.359]                       invisible(muffled)
[17:29:45.359]                     }
[17:29:45.359]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.359]                   }
[17:29:45.359]                 }
[17:29:45.359]             }
[17:29:45.359]         }))
[17:29:45.359]     }, error = function(ex) {
[17:29:45.359]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:45.359]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.359]                 ...future.rng), started = ...future.startTime, 
[17:29:45.359]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:45.359]             version = "1.8"), class = "FutureResult")
[17:29:45.359]     }, finally = {
[17:29:45.359]         if (!identical(...future.workdir, getwd())) 
[17:29:45.359]             setwd(...future.workdir)
[17:29:45.359]         {
[17:29:45.359]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:45.359]                 ...future.oldOptions$nwarnings <- NULL
[17:29:45.359]             }
[17:29:45.359]             base::options(...future.oldOptions)
[17:29:45.359]             if (.Platform$OS.type == "windows") {
[17:29:45.359]                 old_names <- names(...future.oldEnvVars)
[17:29:45.359]                 envs <- base::Sys.getenv()
[17:29:45.359]                 names <- names(envs)
[17:29:45.359]                 common <- intersect(names, old_names)
[17:29:45.359]                 added <- setdiff(names, old_names)
[17:29:45.359]                 removed <- setdiff(old_names, names)
[17:29:45.359]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:45.359]                   envs[common]]
[17:29:45.359]                 NAMES <- toupper(changed)
[17:29:45.359]                 args <- list()
[17:29:45.359]                 for (kk in seq_along(NAMES)) {
[17:29:45.359]                   name <- changed[[kk]]
[17:29:45.359]                   NAME <- NAMES[[kk]]
[17:29:45.359]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.359]                     next
[17:29:45.359]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.359]                 }
[17:29:45.359]                 NAMES <- toupper(added)
[17:29:45.359]                 for (kk in seq_along(NAMES)) {
[17:29:45.359]                   name <- added[[kk]]
[17:29:45.359]                   NAME <- NAMES[[kk]]
[17:29:45.359]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.359]                     next
[17:29:45.359]                   args[[name]] <- ""
[17:29:45.359]                 }
[17:29:45.359]                 NAMES <- toupper(removed)
[17:29:45.359]                 for (kk in seq_along(NAMES)) {
[17:29:45.359]                   name <- removed[[kk]]
[17:29:45.359]                   NAME <- NAMES[[kk]]
[17:29:45.359]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.359]                     next
[17:29:45.359]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.359]                 }
[17:29:45.359]                 if (length(args) > 0) 
[17:29:45.359]                   base::do.call(base::Sys.setenv, args = args)
[17:29:45.359]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:45.359]             }
[17:29:45.359]             else {
[17:29:45.359]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:45.359]             }
[17:29:45.359]             {
[17:29:45.359]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:45.359]                   0L) {
[17:29:45.359]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:45.359]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:45.359]                   base::options(opts)
[17:29:45.359]                 }
[17:29:45.359]                 {
[17:29:45.359]                   {
[17:29:45.359]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:45.359]                     NULL
[17:29:45.359]                   }
[17:29:45.359]                   options(future.plan = NULL)
[17:29:45.359]                   if (is.na(NA_character_)) 
[17:29:45.359]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.359]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:45.359]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:45.359]                     .init = FALSE)
[17:29:45.359]                 }
[17:29:45.359]             }
[17:29:45.359]         }
[17:29:45.359]     })
[17:29:45.359]     if (TRUE) {
[17:29:45.359]         base::sink(type = "output", split = FALSE)
[17:29:45.359]         if (TRUE) {
[17:29:45.359]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:45.359]         }
[17:29:45.359]         else {
[17:29:45.359]             ...future.result["stdout"] <- base::list(NULL)
[17:29:45.359]         }
[17:29:45.359]         base::close(...future.stdout)
[17:29:45.359]         ...future.stdout <- NULL
[17:29:45.359]     }
[17:29:45.359]     ...future.result$conditions <- ...future.conditions
[17:29:45.359]     ...future.result$finished <- base::Sys.time()
[17:29:45.359]     ...future.result
[17:29:45.359] }
[17:29:45.365] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:45.366] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:45.366] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:45.366] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:45.367] MultisessionFuture started
[17:29:45.367] - Launch lazy future ... done
[17:29:45.367] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_2-859974'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001adda74ad48
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:29:45.386] receiveMessageFromWorker() for ClusterFuture ...
[17:29:45.387] - Validating connection of MultisessionFuture
[17:29:45.387] - received message: FutureResult
[17:29:45.388] - Received FutureResult
[17:29:45.388] - Erased future from FutureRegistry
[17:29:45.388] result() for ClusterFuture ...
[17:29:45.388] - result already collected: FutureResult
[17:29:45.389] result() for ClusterFuture ... done
[17:29:45.389] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.390] getGlobalsAndPackages() ...
[17:29:45.390] Searching for globals...
[17:29:45.392] - globals found: [3] '{', 'sample', 'x'
[17:29:45.393] Searching for globals ... DONE
[17:29:45.393] Resolving globals: FALSE
[17:29:45.394] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:45.395] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:45.395] - globals: [1] 'x'
[17:29:45.395] 
[17:29:45.396] getGlobalsAndPackages() ... DONE
[17:29:45.396] run() for 'Future' ...
[17:29:45.397] - state: 'created'
[17:29:45.397] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:45.418] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.419] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:45.419]   - Field: 'node'
[17:29:45.419]   - Field: 'label'
[17:29:45.420]   - Field: 'local'
[17:29:45.420]   - Field: 'owner'
[17:29:45.420]   - Field: 'envir'
[17:29:45.421]   - Field: 'workers'
[17:29:45.421]   - Field: 'packages'
[17:29:45.421]   - Field: 'gc'
[17:29:45.421]   - Field: 'conditions'
[17:29:45.422]   - Field: 'persistent'
[17:29:45.422]   - Field: 'expr'
[17:29:45.422]   - Field: 'uuid'
[17:29:45.423]   - Field: 'seed'
[17:29:45.423]   - Field: 'version'
[17:29:45.423]   - Field: 'result'
[17:29:45.423]   - Field: 'asynchronous'
[17:29:45.424]   - Field: 'calls'
[17:29:45.424]   - Field: 'globals'
[17:29:45.424]   - Field: 'stdout'
[17:29:45.425]   - Field: 'earlySignal'
[17:29:45.425]   - Field: 'lazy'
[17:29:45.425]   - Field: 'state'
[17:29:45.426] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:45.426] - Launch lazy future ...
[17:29:45.426] Packages needed by the future expression (n = 0): <none>
[17:29:45.427] Packages needed by future strategies (n = 0): <none>
[17:29:45.428] {
[17:29:45.428]     {
[17:29:45.428]         {
[17:29:45.428]             ...future.startTime <- base::Sys.time()
[17:29:45.428]             {
[17:29:45.428]                 {
[17:29:45.428]                   {
[17:29:45.428]                     {
[17:29:45.428]                       base::local({
[17:29:45.428]                         has_future <- base::requireNamespace("future", 
[17:29:45.428]                           quietly = TRUE)
[17:29:45.428]                         if (has_future) {
[17:29:45.428]                           ns <- base::getNamespace("future")
[17:29:45.428]                           version <- ns[[".package"]][["version"]]
[17:29:45.428]                           if (is.null(version)) 
[17:29:45.428]                             version <- utils::packageVersion("future")
[17:29:45.428]                         }
[17:29:45.428]                         else {
[17:29:45.428]                           version <- NULL
[17:29:45.428]                         }
[17:29:45.428]                         if (!has_future || version < "1.8.0") {
[17:29:45.428]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:45.428]                             "", base::R.version$version.string), 
[17:29:45.428]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:45.428]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:45.428]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:45.428]                               "release", "version")], collapse = " "), 
[17:29:45.428]                             hostname = base::Sys.info()[["nodename"]])
[17:29:45.428]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:45.428]                             info)
[17:29:45.428]                           info <- base::paste(info, collapse = "; ")
[17:29:45.428]                           if (!has_future) {
[17:29:45.428]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:45.428]                               info)
[17:29:45.428]                           }
[17:29:45.428]                           else {
[17:29:45.428]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:45.428]                               info, version)
[17:29:45.428]                           }
[17:29:45.428]                           base::stop(msg)
[17:29:45.428]                         }
[17:29:45.428]                       })
[17:29:45.428]                     }
[17:29:45.428]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:45.428]                     base::options(mc.cores = 1L)
[17:29:45.428]                   }
[17:29:45.428]                   ...future.strategy.old <- future::plan("list")
[17:29:45.428]                   options(future.plan = NULL)
[17:29:45.428]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.428]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:45.428]                 }
[17:29:45.428]                 ...future.workdir <- getwd()
[17:29:45.428]             }
[17:29:45.428]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:45.428]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:45.428]         }
[17:29:45.428]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:45.428]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:45.428]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:45.428]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:45.428]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:45.428]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:45.428]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:45.428]             base::names(...future.oldOptions))
[17:29:45.428]     }
[17:29:45.428]     if (FALSE) {
[17:29:45.428]     }
[17:29:45.428]     else {
[17:29:45.428]         if (TRUE) {
[17:29:45.428]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:45.428]                 open = "w")
[17:29:45.428]         }
[17:29:45.428]         else {
[17:29:45.428]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:45.428]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:45.428]         }
[17:29:45.428]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:45.428]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:45.428]             base::sink(type = "output", split = FALSE)
[17:29:45.428]             base::close(...future.stdout)
[17:29:45.428]         }, add = TRUE)
[17:29:45.428]     }
[17:29:45.428]     ...future.frame <- base::sys.nframe()
[17:29:45.428]     ...future.conditions <- base::list()
[17:29:45.428]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:45.428]     if (FALSE) {
[17:29:45.428]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:45.428]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:45.428]     }
[17:29:45.428]     ...future.result <- base::tryCatch({
[17:29:45.428]         base::withCallingHandlers({
[17:29:45.428]             ...future.value <- base::withVisible(base::local({
[17:29:45.428]                 ...future.makeSendCondition <- base::local({
[17:29:45.428]                   sendCondition <- NULL
[17:29:45.428]                   function(frame = 1L) {
[17:29:45.428]                     if (is.function(sendCondition)) 
[17:29:45.428]                       return(sendCondition)
[17:29:45.428]                     ns <- getNamespace("parallel")
[17:29:45.428]                     if (exists("sendData", mode = "function", 
[17:29:45.428]                       envir = ns)) {
[17:29:45.428]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:45.428]                         envir = ns)
[17:29:45.428]                       envir <- sys.frame(frame)
[17:29:45.428]                       master <- NULL
[17:29:45.428]                       while (!identical(envir, .GlobalEnv) && 
[17:29:45.428]                         !identical(envir, emptyenv())) {
[17:29:45.428]                         if (exists("master", mode = "list", envir = envir, 
[17:29:45.428]                           inherits = FALSE)) {
[17:29:45.428]                           master <- get("master", mode = "list", 
[17:29:45.428]                             envir = envir, inherits = FALSE)
[17:29:45.428]                           if (inherits(master, c("SOCKnode", 
[17:29:45.428]                             "SOCK0node"))) {
[17:29:45.428]                             sendCondition <<- function(cond) {
[17:29:45.428]                               data <- list(type = "VALUE", value = cond, 
[17:29:45.428]                                 success = TRUE)
[17:29:45.428]                               parallel_sendData(master, data)
[17:29:45.428]                             }
[17:29:45.428]                             return(sendCondition)
[17:29:45.428]                           }
[17:29:45.428]                         }
[17:29:45.428]                         frame <- frame + 1L
[17:29:45.428]                         envir <- sys.frame(frame)
[17:29:45.428]                       }
[17:29:45.428]                     }
[17:29:45.428]                     sendCondition <<- function(cond) NULL
[17:29:45.428]                   }
[17:29:45.428]                 })
[17:29:45.428]                 withCallingHandlers({
[17:29:45.428]                   {
[17:29:45.428]                     sample(x, size = 1L)
[17:29:45.428]                   }
[17:29:45.428]                 }, immediateCondition = function(cond) {
[17:29:45.428]                   sendCondition <- ...future.makeSendCondition()
[17:29:45.428]                   sendCondition(cond)
[17:29:45.428]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.428]                   {
[17:29:45.428]                     inherits <- base::inherits
[17:29:45.428]                     invokeRestart <- base::invokeRestart
[17:29:45.428]                     is.null <- base::is.null
[17:29:45.428]                     muffled <- FALSE
[17:29:45.428]                     if (inherits(cond, "message")) {
[17:29:45.428]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:45.428]                       if (muffled) 
[17:29:45.428]                         invokeRestart("muffleMessage")
[17:29:45.428]                     }
[17:29:45.428]                     else if (inherits(cond, "warning")) {
[17:29:45.428]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:45.428]                       if (muffled) 
[17:29:45.428]                         invokeRestart("muffleWarning")
[17:29:45.428]                     }
[17:29:45.428]                     else if (inherits(cond, "condition")) {
[17:29:45.428]                       if (!is.null(pattern)) {
[17:29:45.428]                         computeRestarts <- base::computeRestarts
[17:29:45.428]                         grepl <- base::grepl
[17:29:45.428]                         restarts <- computeRestarts(cond)
[17:29:45.428]                         for (restart in restarts) {
[17:29:45.428]                           name <- restart$name
[17:29:45.428]                           if (is.null(name)) 
[17:29:45.428]                             next
[17:29:45.428]                           if (!grepl(pattern, name)) 
[17:29:45.428]                             next
[17:29:45.428]                           invokeRestart(restart)
[17:29:45.428]                           muffled <- TRUE
[17:29:45.428]                           break
[17:29:45.428]                         }
[17:29:45.428]                       }
[17:29:45.428]                     }
[17:29:45.428]                     invisible(muffled)
[17:29:45.428]                   }
[17:29:45.428]                   muffleCondition(cond)
[17:29:45.428]                 })
[17:29:45.428]             }))
[17:29:45.428]             future::FutureResult(value = ...future.value$value, 
[17:29:45.428]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.428]                   ...future.rng), globalenv = if (FALSE) 
[17:29:45.428]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:45.428]                     ...future.globalenv.names))
[17:29:45.428]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:45.428]         }, condition = base::local({
[17:29:45.428]             c <- base::c
[17:29:45.428]             inherits <- base::inherits
[17:29:45.428]             invokeRestart <- base::invokeRestart
[17:29:45.428]             length <- base::length
[17:29:45.428]             list <- base::list
[17:29:45.428]             seq.int <- base::seq.int
[17:29:45.428]             signalCondition <- base::signalCondition
[17:29:45.428]             sys.calls <- base::sys.calls
[17:29:45.428]             `[[` <- base::`[[`
[17:29:45.428]             `+` <- base::`+`
[17:29:45.428]             `<<-` <- base::`<<-`
[17:29:45.428]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:45.428]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:45.428]                   3L)]
[17:29:45.428]             }
[17:29:45.428]             function(cond) {
[17:29:45.428]                 is_error <- inherits(cond, "error")
[17:29:45.428]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:45.428]                   NULL)
[17:29:45.428]                 if (is_error) {
[17:29:45.428]                   sessionInformation <- function() {
[17:29:45.428]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:45.428]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:45.428]                       search = base::search(), system = base::Sys.info())
[17:29:45.428]                   }
[17:29:45.428]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.428]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:45.428]                     cond$call), session = sessionInformation(), 
[17:29:45.428]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:45.428]                   signalCondition(cond)
[17:29:45.428]                 }
[17:29:45.428]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:45.428]                 "immediateCondition"))) {
[17:29:45.428]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:45.428]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.428]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:45.428]                   if (TRUE && !signal) {
[17:29:45.428]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.428]                     {
[17:29:45.428]                       inherits <- base::inherits
[17:29:45.428]                       invokeRestart <- base::invokeRestart
[17:29:45.428]                       is.null <- base::is.null
[17:29:45.428]                       muffled <- FALSE
[17:29:45.428]                       if (inherits(cond, "message")) {
[17:29:45.428]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.428]                         if (muffled) 
[17:29:45.428]                           invokeRestart("muffleMessage")
[17:29:45.428]                       }
[17:29:45.428]                       else if (inherits(cond, "warning")) {
[17:29:45.428]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.428]                         if (muffled) 
[17:29:45.428]                           invokeRestart("muffleWarning")
[17:29:45.428]                       }
[17:29:45.428]                       else if (inherits(cond, "condition")) {
[17:29:45.428]                         if (!is.null(pattern)) {
[17:29:45.428]                           computeRestarts <- base::computeRestarts
[17:29:45.428]                           grepl <- base::grepl
[17:29:45.428]                           restarts <- computeRestarts(cond)
[17:29:45.428]                           for (restart in restarts) {
[17:29:45.428]                             name <- restart$name
[17:29:45.428]                             if (is.null(name)) 
[17:29:45.428]                               next
[17:29:45.428]                             if (!grepl(pattern, name)) 
[17:29:45.428]                               next
[17:29:45.428]                             invokeRestart(restart)
[17:29:45.428]                             muffled <- TRUE
[17:29:45.428]                             break
[17:29:45.428]                           }
[17:29:45.428]                         }
[17:29:45.428]                       }
[17:29:45.428]                       invisible(muffled)
[17:29:45.428]                     }
[17:29:45.428]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.428]                   }
[17:29:45.428]                 }
[17:29:45.428]                 else {
[17:29:45.428]                   if (TRUE) {
[17:29:45.428]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.428]                     {
[17:29:45.428]                       inherits <- base::inherits
[17:29:45.428]                       invokeRestart <- base::invokeRestart
[17:29:45.428]                       is.null <- base::is.null
[17:29:45.428]                       muffled <- FALSE
[17:29:45.428]                       if (inherits(cond, "message")) {
[17:29:45.428]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.428]                         if (muffled) 
[17:29:45.428]                           invokeRestart("muffleMessage")
[17:29:45.428]                       }
[17:29:45.428]                       else if (inherits(cond, "warning")) {
[17:29:45.428]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.428]                         if (muffled) 
[17:29:45.428]                           invokeRestart("muffleWarning")
[17:29:45.428]                       }
[17:29:45.428]                       else if (inherits(cond, "condition")) {
[17:29:45.428]                         if (!is.null(pattern)) {
[17:29:45.428]                           computeRestarts <- base::computeRestarts
[17:29:45.428]                           grepl <- base::grepl
[17:29:45.428]                           restarts <- computeRestarts(cond)
[17:29:45.428]                           for (restart in restarts) {
[17:29:45.428]                             name <- restart$name
[17:29:45.428]                             if (is.null(name)) 
[17:29:45.428]                               next
[17:29:45.428]                             if (!grepl(pattern, name)) 
[17:29:45.428]                               next
[17:29:45.428]                             invokeRestart(restart)
[17:29:45.428]                             muffled <- TRUE
[17:29:45.428]                             break
[17:29:45.428]                           }
[17:29:45.428]                         }
[17:29:45.428]                       }
[17:29:45.428]                       invisible(muffled)
[17:29:45.428]                     }
[17:29:45.428]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.428]                   }
[17:29:45.428]                 }
[17:29:45.428]             }
[17:29:45.428]         }))
[17:29:45.428]     }, error = function(ex) {
[17:29:45.428]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:45.428]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.428]                 ...future.rng), started = ...future.startTime, 
[17:29:45.428]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:45.428]             version = "1.8"), class = "FutureResult")
[17:29:45.428]     }, finally = {
[17:29:45.428]         if (!identical(...future.workdir, getwd())) 
[17:29:45.428]             setwd(...future.workdir)
[17:29:45.428]         {
[17:29:45.428]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:45.428]                 ...future.oldOptions$nwarnings <- NULL
[17:29:45.428]             }
[17:29:45.428]             base::options(...future.oldOptions)
[17:29:45.428]             if (.Platform$OS.type == "windows") {
[17:29:45.428]                 old_names <- names(...future.oldEnvVars)
[17:29:45.428]                 envs <- base::Sys.getenv()
[17:29:45.428]                 names <- names(envs)
[17:29:45.428]                 common <- intersect(names, old_names)
[17:29:45.428]                 added <- setdiff(names, old_names)
[17:29:45.428]                 removed <- setdiff(old_names, names)
[17:29:45.428]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:45.428]                   envs[common]]
[17:29:45.428]                 NAMES <- toupper(changed)
[17:29:45.428]                 args <- list()
[17:29:45.428]                 for (kk in seq_along(NAMES)) {
[17:29:45.428]                   name <- changed[[kk]]
[17:29:45.428]                   NAME <- NAMES[[kk]]
[17:29:45.428]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.428]                     next
[17:29:45.428]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.428]                 }
[17:29:45.428]                 NAMES <- toupper(added)
[17:29:45.428]                 for (kk in seq_along(NAMES)) {
[17:29:45.428]                   name <- added[[kk]]
[17:29:45.428]                   NAME <- NAMES[[kk]]
[17:29:45.428]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.428]                     next
[17:29:45.428]                   args[[name]] <- ""
[17:29:45.428]                 }
[17:29:45.428]                 NAMES <- toupper(removed)
[17:29:45.428]                 for (kk in seq_along(NAMES)) {
[17:29:45.428]                   name <- removed[[kk]]
[17:29:45.428]                   NAME <- NAMES[[kk]]
[17:29:45.428]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.428]                     next
[17:29:45.428]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.428]                 }
[17:29:45.428]                 if (length(args) > 0) 
[17:29:45.428]                   base::do.call(base::Sys.setenv, args = args)
[17:29:45.428]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:45.428]             }
[17:29:45.428]             else {
[17:29:45.428]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:45.428]             }
[17:29:45.428]             {
[17:29:45.428]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:45.428]                   0L) {
[17:29:45.428]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:45.428]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:45.428]                   base::options(opts)
[17:29:45.428]                 }
[17:29:45.428]                 {
[17:29:45.428]                   {
[17:29:45.428]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:45.428]                     NULL
[17:29:45.428]                   }
[17:29:45.428]                   options(future.plan = NULL)
[17:29:45.428]                   if (is.na(NA_character_)) 
[17:29:45.428]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.428]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:45.428]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:45.428]                     .init = FALSE)
[17:29:45.428]                 }
[17:29:45.428]             }
[17:29:45.428]         }
[17:29:45.428]     })
[17:29:45.428]     if (TRUE) {
[17:29:45.428]         base::sink(type = "output", split = FALSE)
[17:29:45.428]         if (TRUE) {
[17:29:45.428]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:45.428]         }
[17:29:45.428]         else {
[17:29:45.428]             ...future.result["stdout"] <- base::list(NULL)
[17:29:45.428]         }
[17:29:45.428]         base::close(...future.stdout)
[17:29:45.428]         ...future.stdout <- NULL
[17:29:45.428]     }
[17:29:45.428]     ...future.result$conditions <- ...future.conditions
[17:29:45.428]     ...future.result$finished <- base::Sys.time()
[17:29:45.428]     ...future.result
[17:29:45.428] }
[17:29:45.434] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:45.434] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:45.435] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:45.436] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:45.437] MultisessionFuture started
[17:29:45.437] - Launch lazy future ... done
[17:29:45.438] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_3-78525'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001adda74ad48
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:29:45.455] receiveMessageFromWorker() for ClusterFuture ...
[17:29:45.456] - Validating connection of MultisessionFuture
[17:29:45.456] - received message: FutureResult
[17:29:45.457] - Received FutureResult
[17:29:45.458] - Erased future from FutureRegistry
[17:29:45.458] result() for ClusterFuture ...
[17:29:45.458] - result already collected: FutureResult
[17:29:45.458] result() for ClusterFuture ... done
[17:29:45.459] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.459] getGlobalsAndPackages() ...
[17:29:45.459] Searching for globals...
[17:29:45.461] - globals found: [3] '{', 'sample', 'x'
[17:29:45.462] Searching for globals ... DONE
[17:29:45.462] Resolving globals: FALSE
[17:29:45.463] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:45.463] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:45.464] - globals: [1] 'x'
[17:29:45.464] 
[17:29:45.464] getGlobalsAndPackages() ... DONE
[17:29:45.465] run() for 'Future' ...
[17:29:45.465] - state: 'created'
[17:29:45.465] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:45.484] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.484] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:45.485]   - Field: 'node'
[17:29:45.485]   - Field: 'label'
[17:29:45.485]   - Field: 'local'
[17:29:45.486]   - Field: 'owner'
[17:29:45.486]   - Field: 'envir'
[17:29:45.486]   - Field: 'workers'
[17:29:45.487]   - Field: 'packages'
[17:29:45.487]   - Field: 'gc'
[17:29:45.487]   - Field: 'conditions'
[17:29:45.488]   - Field: 'persistent'
[17:29:45.488]   - Field: 'expr'
[17:29:45.488]   - Field: 'uuid'
[17:29:45.489]   - Field: 'seed'
[17:29:45.489]   - Field: 'version'
[17:29:45.489]   - Field: 'result'
[17:29:45.490]   - Field: 'asynchronous'
[17:29:45.490]   - Field: 'calls'
[17:29:45.490]   - Field: 'globals'
[17:29:45.491]   - Field: 'stdout'
[17:29:45.491]   - Field: 'earlySignal'
[17:29:45.491]   - Field: 'lazy'
[17:29:45.492]   - Field: 'state'
[17:29:45.492] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:45.492] - Launch lazy future ...
[17:29:45.496] Packages needed by the future expression (n = 0): <none>
[17:29:45.497] Packages needed by future strategies (n = 0): <none>
[17:29:45.498] {
[17:29:45.498]     {
[17:29:45.498]         {
[17:29:45.498]             ...future.startTime <- base::Sys.time()
[17:29:45.498]             {
[17:29:45.498]                 {
[17:29:45.498]                   {
[17:29:45.498]                     {
[17:29:45.498]                       base::local({
[17:29:45.498]                         has_future <- base::requireNamespace("future", 
[17:29:45.498]                           quietly = TRUE)
[17:29:45.498]                         if (has_future) {
[17:29:45.498]                           ns <- base::getNamespace("future")
[17:29:45.498]                           version <- ns[[".package"]][["version"]]
[17:29:45.498]                           if (is.null(version)) 
[17:29:45.498]                             version <- utils::packageVersion("future")
[17:29:45.498]                         }
[17:29:45.498]                         else {
[17:29:45.498]                           version <- NULL
[17:29:45.498]                         }
[17:29:45.498]                         if (!has_future || version < "1.8.0") {
[17:29:45.498]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:45.498]                             "", base::R.version$version.string), 
[17:29:45.498]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:45.498]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:45.498]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:45.498]                               "release", "version")], collapse = " "), 
[17:29:45.498]                             hostname = base::Sys.info()[["nodename"]])
[17:29:45.498]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:45.498]                             info)
[17:29:45.498]                           info <- base::paste(info, collapse = "; ")
[17:29:45.498]                           if (!has_future) {
[17:29:45.498]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:45.498]                               info)
[17:29:45.498]                           }
[17:29:45.498]                           else {
[17:29:45.498]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:45.498]                               info, version)
[17:29:45.498]                           }
[17:29:45.498]                           base::stop(msg)
[17:29:45.498]                         }
[17:29:45.498]                       })
[17:29:45.498]                     }
[17:29:45.498]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:45.498]                     base::options(mc.cores = 1L)
[17:29:45.498]                   }
[17:29:45.498]                   ...future.strategy.old <- future::plan("list")
[17:29:45.498]                   options(future.plan = NULL)
[17:29:45.498]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.498]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:45.498]                 }
[17:29:45.498]                 ...future.workdir <- getwd()
[17:29:45.498]             }
[17:29:45.498]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:45.498]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:45.498]         }
[17:29:45.498]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:45.498]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:45.498]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:45.498]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:45.498]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:45.498]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:45.498]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:45.498]             base::names(...future.oldOptions))
[17:29:45.498]     }
[17:29:45.498]     if (FALSE) {
[17:29:45.498]     }
[17:29:45.498]     else {
[17:29:45.498]         if (TRUE) {
[17:29:45.498]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:45.498]                 open = "w")
[17:29:45.498]         }
[17:29:45.498]         else {
[17:29:45.498]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:45.498]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:45.498]         }
[17:29:45.498]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:45.498]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:45.498]             base::sink(type = "output", split = FALSE)
[17:29:45.498]             base::close(...future.stdout)
[17:29:45.498]         }, add = TRUE)
[17:29:45.498]     }
[17:29:45.498]     ...future.frame <- base::sys.nframe()
[17:29:45.498]     ...future.conditions <- base::list()
[17:29:45.498]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:45.498]     if (FALSE) {
[17:29:45.498]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:45.498]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:45.498]     }
[17:29:45.498]     ...future.result <- base::tryCatch({
[17:29:45.498]         base::withCallingHandlers({
[17:29:45.498]             ...future.value <- base::withVisible(base::local({
[17:29:45.498]                 ...future.makeSendCondition <- base::local({
[17:29:45.498]                   sendCondition <- NULL
[17:29:45.498]                   function(frame = 1L) {
[17:29:45.498]                     if (is.function(sendCondition)) 
[17:29:45.498]                       return(sendCondition)
[17:29:45.498]                     ns <- getNamespace("parallel")
[17:29:45.498]                     if (exists("sendData", mode = "function", 
[17:29:45.498]                       envir = ns)) {
[17:29:45.498]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:45.498]                         envir = ns)
[17:29:45.498]                       envir <- sys.frame(frame)
[17:29:45.498]                       master <- NULL
[17:29:45.498]                       while (!identical(envir, .GlobalEnv) && 
[17:29:45.498]                         !identical(envir, emptyenv())) {
[17:29:45.498]                         if (exists("master", mode = "list", envir = envir, 
[17:29:45.498]                           inherits = FALSE)) {
[17:29:45.498]                           master <- get("master", mode = "list", 
[17:29:45.498]                             envir = envir, inherits = FALSE)
[17:29:45.498]                           if (inherits(master, c("SOCKnode", 
[17:29:45.498]                             "SOCK0node"))) {
[17:29:45.498]                             sendCondition <<- function(cond) {
[17:29:45.498]                               data <- list(type = "VALUE", value = cond, 
[17:29:45.498]                                 success = TRUE)
[17:29:45.498]                               parallel_sendData(master, data)
[17:29:45.498]                             }
[17:29:45.498]                             return(sendCondition)
[17:29:45.498]                           }
[17:29:45.498]                         }
[17:29:45.498]                         frame <- frame + 1L
[17:29:45.498]                         envir <- sys.frame(frame)
[17:29:45.498]                       }
[17:29:45.498]                     }
[17:29:45.498]                     sendCondition <<- function(cond) NULL
[17:29:45.498]                   }
[17:29:45.498]                 })
[17:29:45.498]                 withCallingHandlers({
[17:29:45.498]                   {
[17:29:45.498]                     sample(x, size = 1L)
[17:29:45.498]                   }
[17:29:45.498]                 }, immediateCondition = function(cond) {
[17:29:45.498]                   sendCondition <- ...future.makeSendCondition()
[17:29:45.498]                   sendCondition(cond)
[17:29:45.498]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.498]                   {
[17:29:45.498]                     inherits <- base::inherits
[17:29:45.498]                     invokeRestart <- base::invokeRestart
[17:29:45.498]                     is.null <- base::is.null
[17:29:45.498]                     muffled <- FALSE
[17:29:45.498]                     if (inherits(cond, "message")) {
[17:29:45.498]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:45.498]                       if (muffled) 
[17:29:45.498]                         invokeRestart("muffleMessage")
[17:29:45.498]                     }
[17:29:45.498]                     else if (inherits(cond, "warning")) {
[17:29:45.498]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:45.498]                       if (muffled) 
[17:29:45.498]                         invokeRestart("muffleWarning")
[17:29:45.498]                     }
[17:29:45.498]                     else if (inherits(cond, "condition")) {
[17:29:45.498]                       if (!is.null(pattern)) {
[17:29:45.498]                         computeRestarts <- base::computeRestarts
[17:29:45.498]                         grepl <- base::grepl
[17:29:45.498]                         restarts <- computeRestarts(cond)
[17:29:45.498]                         for (restart in restarts) {
[17:29:45.498]                           name <- restart$name
[17:29:45.498]                           if (is.null(name)) 
[17:29:45.498]                             next
[17:29:45.498]                           if (!grepl(pattern, name)) 
[17:29:45.498]                             next
[17:29:45.498]                           invokeRestart(restart)
[17:29:45.498]                           muffled <- TRUE
[17:29:45.498]                           break
[17:29:45.498]                         }
[17:29:45.498]                       }
[17:29:45.498]                     }
[17:29:45.498]                     invisible(muffled)
[17:29:45.498]                   }
[17:29:45.498]                   muffleCondition(cond)
[17:29:45.498]                 })
[17:29:45.498]             }))
[17:29:45.498]             future::FutureResult(value = ...future.value$value, 
[17:29:45.498]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.498]                   ...future.rng), globalenv = if (FALSE) 
[17:29:45.498]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:45.498]                     ...future.globalenv.names))
[17:29:45.498]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:45.498]         }, condition = base::local({
[17:29:45.498]             c <- base::c
[17:29:45.498]             inherits <- base::inherits
[17:29:45.498]             invokeRestart <- base::invokeRestart
[17:29:45.498]             length <- base::length
[17:29:45.498]             list <- base::list
[17:29:45.498]             seq.int <- base::seq.int
[17:29:45.498]             signalCondition <- base::signalCondition
[17:29:45.498]             sys.calls <- base::sys.calls
[17:29:45.498]             `[[` <- base::`[[`
[17:29:45.498]             `+` <- base::`+`
[17:29:45.498]             `<<-` <- base::`<<-`
[17:29:45.498]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:45.498]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:45.498]                   3L)]
[17:29:45.498]             }
[17:29:45.498]             function(cond) {
[17:29:45.498]                 is_error <- inherits(cond, "error")
[17:29:45.498]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:45.498]                   NULL)
[17:29:45.498]                 if (is_error) {
[17:29:45.498]                   sessionInformation <- function() {
[17:29:45.498]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:45.498]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:45.498]                       search = base::search(), system = base::Sys.info())
[17:29:45.498]                   }
[17:29:45.498]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.498]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:45.498]                     cond$call), session = sessionInformation(), 
[17:29:45.498]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:45.498]                   signalCondition(cond)
[17:29:45.498]                 }
[17:29:45.498]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:45.498]                 "immediateCondition"))) {
[17:29:45.498]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:45.498]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.498]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:45.498]                   if (TRUE && !signal) {
[17:29:45.498]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.498]                     {
[17:29:45.498]                       inherits <- base::inherits
[17:29:45.498]                       invokeRestart <- base::invokeRestart
[17:29:45.498]                       is.null <- base::is.null
[17:29:45.498]                       muffled <- FALSE
[17:29:45.498]                       if (inherits(cond, "message")) {
[17:29:45.498]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.498]                         if (muffled) 
[17:29:45.498]                           invokeRestart("muffleMessage")
[17:29:45.498]                       }
[17:29:45.498]                       else if (inherits(cond, "warning")) {
[17:29:45.498]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.498]                         if (muffled) 
[17:29:45.498]                           invokeRestart("muffleWarning")
[17:29:45.498]                       }
[17:29:45.498]                       else if (inherits(cond, "condition")) {
[17:29:45.498]                         if (!is.null(pattern)) {
[17:29:45.498]                           computeRestarts <- base::computeRestarts
[17:29:45.498]                           grepl <- base::grepl
[17:29:45.498]                           restarts <- computeRestarts(cond)
[17:29:45.498]                           for (restart in restarts) {
[17:29:45.498]                             name <- restart$name
[17:29:45.498]                             if (is.null(name)) 
[17:29:45.498]                               next
[17:29:45.498]                             if (!grepl(pattern, name)) 
[17:29:45.498]                               next
[17:29:45.498]                             invokeRestart(restart)
[17:29:45.498]                             muffled <- TRUE
[17:29:45.498]                             break
[17:29:45.498]                           }
[17:29:45.498]                         }
[17:29:45.498]                       }
[17:29:45.498]                       invisible(muffled)
[17:29:45.498]                     }
[17:29:45.498]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.498]                   }
[17:29:45.498]                 }
[17:29:45.498]                 else {
[17:29:45.498]                   if (TRUE) {
[17:29:45.498]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.498]                     {
[17:29:45.498]                       inherits <- base::inherits
[17:29:45.498]                       invokeRestart <- base::invokeRestart
[17:29:45.498]                       is.null <- base::is.null
[17:29:45.498]                       muffled <- FALSE
[17:29:45.498]                       if (inherits(cond, "message")) {
[17:29:45.498]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.498]                         if (muffled) 
[17:29:45.498]                           invokeRestart("muffleMessage")
[17:29:45.498]                       }
[17:29:45.498]                       else if (inherits(cond, "warning")) {
[17:29:45.498]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.498]                         if (muffled) 
[17:29:45.498]                           invokeRestart("muffleWarning")
[17:29:45.498]                       }
[17:29:45.498]                       else if (inherits(cond, "condition")) {
[17:29:45.498]                         if (!is.null(pattern)) {
[17:29:45.498]                           computeRestarts <- base::computeRestarts
[17:29:45.498]                           grepl <- base::grepl
[17:29:45.498]                           restarts <- computeRestarts(cond)
[17:29:45.498]                           for (restart in restarts) {
[17:29:45.498]                             name <- restart$name
[17:29:45.498]                             if (is.null(name)) 
[17:29:45.498]                               next
[17:29:45.498]                             if (!grepl(pattern, name)) 
[17:29:45.498]                               next
[17:29:45.498]                             invokeRestart(restart)
[17:29:45.498]                             muffled <- TRUE
[17:29:45.498]                             break
[17:29:45.498]                           }
[17:29:45.498]                         }
[17:29:45.498]                       }
[17:29:45.498]                       invisible(muffled)
[17:29:45.498]                     }
[17:29:45.498]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.498]                   }
[17:29:45.498]                 }
[17:29:45.498]             }
[17:29:45.498]         }))
[17:29:45.498]     }, error = function(ex) {
[17:29:45.498]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:45.498]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.498]                 ...future.rng), started = ...future.startTime, 
[17:29:45.498]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:45.498]             version = "1.8"), class = "FutureResult")
[17:29:45.498]     }, finally = {
[17:29:45.498]         if (!identical(...future.workdir, getwd())) 
[17:29:45.498]             setwd(...future.workdir)
[17:29:45.498]         {
[17:29:45.498]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:45.498]                 ...future.oldOptions$nwarnings <- NULL
[17:29:45.498]             }
[17:29:45.498]             base::options(...future.oldOptions)
[17:29:45.498]             if (.Platform$OS.type == "windows") {
[17:29:45.498]                 old_names <- names(...future.oldEnvVars)
[17:29:45.498]                 envs <- base::Sys.getenv()
[17:29:45.498]                 names <- names(envs)
[17:29:45.498]                 common <- intersect(names, old_names)
[17:29:45.498]                 added <- setdiff(names, old_names)
[17:29:45.498]                 removed <- setdiff(old_names, names)
[17:29:45.498]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:45.498]                   envs[common]]
[17:29:45.498]                 NAMES <- toupper(changed)
[17:29:45.498]                 args <- list()
[17:29:45.498]                 for (kk in seq_along(NAMES)) {
[17:29:45.498]                   name <- changed[[kk]]
[17:29:45.498]                   NAME <- NAMES[[kk]]
[17:29:45.498]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.498]                     next
[17:29:45.498]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.498]                 }
[17:29:45.498]                 NAMES <- toupper(added)
[17:29:45.498]                 for (kk in seq_along(NAMES)) {
[17:29:45.498]                   name <- added[[kk]]
[17:29:45.498]                   NAME <- NAMES[[kk]]
[17:29:45.498]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.498]                     next
[17:29:45.498]                   args[[name]] <- ""
[17:29:45.498]                 }
[17:29:45.498]                 NAMES <- toupper(removed)
[17:29:45.498]                 for (kk in seq_along(NAMES)) {
[17:29:45.498]                   name <- removed[[kk]]
[17:29:45.498]                   NAME <- NAMES[[kk]]
[17:29:45.498]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.498]                     next
[17:29:45.498]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.498]                 }
[17:29:45.498]                 if (length(args) > 0) 
[17:29:45.498]                   base::do.call(base::Sys.setenv, args = args)
[17:29:45.498]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:45.498]             }
[17:29:45.498]             else {
[17:29:45.498]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:45.498]             }
[17:29:45.498]             {
[17:29:45.498]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:45.498]                   0L) {
[17:29:45.498]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:45.498]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:45.498]                   base::options(opts)
[17:29:45.498]                 }
[17:29:45.498]                 {
[17:29:45.498]                   {
[17:29:45.498]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:45.498]                     NULL
[17:29:45.498]                   }
[17:29:45.498]                   options(future.plan = NULL)
[17:29:45.498]                   if (is.na(NA_character_)) 
[17:29:45.498]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.498]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:45.498]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:45.498]                     .init = FALSE)
[17:29:45.498]                 }
[17:29:45.498]             }
[17:29:45.498]         }
[17:29:45.498]     })
[17:29:45.498]     if (TRUE) {
[17:29:45.498]         base::sink(type = "output", split = FALSE)
[17:29:45.498]         if (TRUE) {
[17:29:45.498]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:45.498]         }
[17:29:45.498]         else {
[17:29:45.498]             ...future.result["stdout"] <- base::list(NULL)
[17:29:45.498]         }
[17:29:45.498]         base::close(...future.stdout)
[17:29:45.498]         ...future.stdout <- NULL
[17:29:45.498]     }
[17:29:45.498]     ...future.result$conditions <- ...future.conditions
[17:29:45.498]     ...future.result$finished <- base::Sys.time()
[17:29:45.498]     ...future.result
[17:29:45.498] }
[17:29:45.507] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:45.507] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:45.508] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:45.508] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:45.509] MultisessionFuture started
[17:29:45.509] - Launch lazy future ... done
[17:29:45.509] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_4-385717'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001adda74ad48
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:29:45.529] receiveMessageFromWorker() for ClusterFuture ...
[17:29:45.530] - Validating connection of MultisessionFuture
[17:29:45.530] - received message: FutureResult
[17:29:45.531] - Received FutureResult
[17:29:45.531] - Erased future from FutureRegistry
[17:29:45.531] result() for ClusterFuture ...
[17:29:45.531] - result already collected: FutureResult
[17:29:45.532] result() for ClusterFuture ... done
[17:29:45.532] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.532] resolve() on list ...
[17:29:45.532]  recursive: 0
[17:29:45.533]  length: 4
[17:29:45.533] 
[17:29:45.533] Future #1
[17:29:45.533] result() for ClusterFuture ...
[17:29:45.534] - result already collected: FutureResult
[17:29:45.534] result() for ClusterFuture ... done
[17:29:45.534] result() for ClusterFuture ...
[17:29:45.534] - result already collected: FutureResult
[17:29:45.534] result() for ClusterFuture ... done
[17:29:45.535] signalConditionsASAP(MultisessionFuture, pos=1) ...
[17:29:45.535] - nx: 4
[17:29:45.535] - relay: TRUE
[17:29:45.536] - stdout: TRUE
[17:29:45.536] - signal: TRUE
[17:29:45.536] - resignal: FALSE
[17:29:45.536] - force: TRUE
[17:29:45.536] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:45.537] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:45.537]  - until=1
[17:29:45.537]  - relaying element #1
[17:29:45.537] result() for ClusterFuture ...
[17:29:45.537] - result already collected: FutureResult
[17:29:45.538] result() for ClusterFuture ... done
[17:29:45.538] result() for ClusterFuture ...
[17:29:45.538] - result already collected: FutureResult
[17:29:45.538] result() for ClusterFuture ... done
[17:29:45.539] result() for ClusterFuture ...
[17:29:45.539] - result already collected: FutureResult
[17:29:45.539] result() for ClusterFuture ... done
[17:29:45.539] result() for ClusterFuture ...
[17:29:45.539] - result already collected: FutureResult
[17:29:45.540] result() for ClusterFuture ... done
[17:29:45.540] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:45.540] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:45.540] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[17:29:45.541]  length: 3 (resolved future 1)
[17:29:45.541] Future #2
[17:29:45.541] result() for ClusterFuture ...
[17:29:45.541] - result already collected: FutureResult
[17:29:45.542] result() for ClusterFuture ... done
[17:29:45.542] result() for ClusterFuture ...
[17:29:45.542] - result already collected: FutureResult
[17:29:45.542] result() for ClusterFuture ... done
[17:29:45.542] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:29:45.543] - nx: 4
[17:29:45.543] - relay: TRUE
[17:29:45.543] - stdout: TRUE
[17:29:45.543] - signal: TRUE
[17:29:45.543] - resignal: FALSE
[17:29:45.544] - force: TRUE
[17:29:45.544] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:45.544] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:45.544]  - until=2
[17:29:45.544]  - relaying element #2
[17:29:45.545] result() for ClusterFuture ...
[17:29:45.545] - result already collected: FutureResult
[17:29:45.545] result() for ClusterFuture ... done
[17:29:45.545] result() for ClusterFuture ...
[17:29:45.546] - result already collected: FutureResult
[17:29:45.546] result() for ClusterFuture ... done
[17:29:45.546] result() for ClusterFuture ...
[17:29:45.546] - result already collected: FutureResult
[17:29:45.546] result() for ClusterFuture ... done
[17:29:45.547] result() for ClusterFuture ...
[17:29:45.547] - result already collected: FutureResult
[17:29:45.547] result() for ClusterFuture ... done
[17:29:45.547] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:45.548] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:45.548] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:29:45.548]  length: 2 (resolved future 2)
[17:29:45.548] Future #3
[17:29:45.549] result() for ClusterFuture ...
[17:29:45.549] - result already collected: FutureResult
[17:29:45.549] result() for ClusterFuture ... done
[17:29:45.549] result() for ClusterFuture ...
[17:29:45.549] - result already collected: FutureResult
[17:29:45.550] result() for ClusterFuture ... done
[17:29:45.550] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:29:45.550] - nx: 4
[17:29:45.550] - relay: TRUE
[17:29:45.550] - stdout: TRUE
[17:29:45.551] - signal: TRUE
[17:29:45.551] - resignal: FALSE
[17:29:45.551] - force: TRUE
[17:29:45.551] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:45.552] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:45.552]  - until=3
[17:29:45.552]  - relaying element #3
[17:29:45.552] result() for ClusterFuture ...
[17:29:45.552] - result already collected: FutureResult
[17:29:45.553] result() for ClusterFuture ... done
[17:29:45.553] result() for ClusterFuture ...
[17:29:45.553] - result already collected: FutureResult
[17:29:45.553] result() for ClusterFuture ... done
[17:29:45.554] result() for ClusterFuture ...
[17:29:45.554] - result already collected: FutureResult
[17:29:45.554] result() for ClusterFuture ... done
[17:29:45.554] result() for ClusterFuture ...
[17:29:45.554] - result already collected: FutureResult
[17:29:45.555] result() for ClusterFuture ... done
[17:29:45.555] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:45.555] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:45.555] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:29:45.555]  length: 1 (resolved future 3)
[17:29:45.556] Future #4
[17:29:45.556] result() for ClusterFuture ...
[17:29:45.556] - result already collected: FutureResult
[17:29:45.556] result() for ClusterFuture ... done
[17:29:45.557] result() for ClusterFuture ...
[17:29:45.557] - result already collected: FutureResult
[17:29:45.557] result() for ClusterFuture ... done
[17:29:45.557] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:29:45.557] - nx: 4
[17:29:45.558] - relay: TRUE
[17:29:45.558] - stdout: TRUE
[17:29:45.558] - signal: TRUE
[17:29:45.558] - resignal: FALSE
[17:29:45.558] - force: TRUE
[17:29:45.559] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:45.559] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:45.559]  - until=4
[17:29:45.559]  - relaying element #4
[17:29:45.560] result() for ClusterFuture ...
[17:29:45.560] - result already collected: FutureResult
[17:29:45.560] result() for ClusterFuture ... done
[17:29:45.560] result() for ClusterFuture ...
[17:29:45.560] - result already collected: FutureResult
[17:29:45.561] result() for ClusterFuture ... done
[17:29:45.561] result() for ClusterFuture ...
[17:29:45.561] - result already collected: FutureResult
[17:29:45.561] result() for ClusterFuture ... done
[17:29:45.562] result() for ClusterFuture ...
[17:29:45.562] - result already collected: FutureResult
[17:29:45.562] result() for ClusterFuture ... done
[17:29:45.562] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:45.562] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:45.563] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:29:45.563]  length: 0 (resolved future 4)
[17:29:45.563] Relaying remaining futures
[17:29:45.563] signalConditionsASAP(NULL, pos=0) ...
[17:29:45.563] - nx: 4
[17:29:45.564] - relay: TRUE
[17:29:45.564] - stdout: TRUE
[17:29:45.564] - signal: TRUE
[17:29:45.564] - resignal: FALSE
[17:29:45.564] - force: TRUE
[17:29:45.565] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:45.565] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:29:45.565] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:45.565] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:45.566] signalConditionsASAP(NULL, pos=0) ... done
[17:29:45.566] resolve() on list ... DONE
[17:29:45.566] result() for ClusterFuture ...
[17:29:45.566] - result already collected: FutureResult
[17:29:45.566] result() for ClusterFuture ... done
[17:29:45.567] result() for ClusterFuture ...
[17:29:45.567] - result already collected: FutureResult
[17:29:45.567] result() for ClusterFuture ... done
[17:29:45.567] result() for ClusterFuture ...
[17:29:45.568] - result already collected: FutureResult
[17:29:45.568] result() for ClusterFuture ... done
[17:29:45.568] result() for ClusterFuture ...
[17:29:45.568] - result already collected: FutureResult
[17:29:45.568] result() for ClusterFuture ... done
[17:29:45.569] result() for ClusterFuture ...
[17:29:45.569] - result already collected: FutureResult
[17:29:45.569] result() for ClusterFuture ... done
[17:29:45.569] result() for ClusterFuture ...
[17:29:45.570] - result already collected: FutureResult
[17:29:45.570] result() for ClusterFuture ... done
[17:29:45.570] result() for ClusterFuture ...
[17:29:45.570] - result already collected: FutureResult
[17:29:45.570] result() for ClusterFuture ... done
[17:29:45.571] result() for ClusterFuture ...
[17:29:45.571] - result already collected: FutureResult
[17:29:45.571] result() for ClusterFuture ... done
[[1]]
[1] 0

[[2]]
[1] 2

[[3]]
[1] 0

[[4]]
[1] 3

[17:29:45.571] getGlobalsAndPackages() ...
[17:29:45.571] Searching for globals...
[17:29:45.573] - globals found: [3] '{', 'sample', 'x'
[17:29:45.573] Searching for globals ... DONE
[17:29:45.573] Resolving globals: FALSE
[17:29:45.574] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:45.574] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:45.574] - globals: [1] 'x'
[17:29:45.575] 
[17:29:45.575] getGlobalsAndPackages() ... DONE
[17:29:45.575] run() for 'Future' ...
[17:29:45.575] - state: 'created'
[17:29:45.576] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:45.591] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.592] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:45.592]   - Field: 'node'
[17:29:45.592]   - Field: 'label'
[17:29:45.592]   - Field: 'local'
[17:29:45.593]   - Field: 'owner'
[17:29:45.593]   - Field: 'envir'
[17:29:45.593]   - Field: 'workers'
[17:29:45.593]   - Field: 'packages'
[17:29:45.593]   - Field: 'gc'
[17:29:45.594]   - Field: 'conditions'
[17:29:45.594]   - Field: 'persistent'
[17:29:45.594]   - Field: 'expr'
[17:29:45.594]   - Field: 'uuid'
[17:29:45.594]   - Field: 'seed'
[17:29:45.595]   - Field: 'version'
[17:29:45.595]   - Field: 'result'
[17:29:45.595]   - Field: 'asynchronous'
[17:29:45.595]   - Field: 'calls'
[17:29:45.595]   - Field: 'globals'
[17:29:45.595]   - Field: 'stdout'
[17:29:45.596]   - Field: 'earlySignal'
[17:29:45.596]   - Field: 'lazy'
[17:29:45.596]   - Field: 'state'
[17:29:45.596] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:45.596] - Launch lazy future ...
[17:29:45.597] Packages needed by the future expression (n = 0): <none>
[17:29:45.597] Packages needed by future strategies (n = 0): <none>
[17:29:45.598] {
[17:29:45.598]     {
[17:29:45.598]         {
[17:29:45.598]             ...future.startTime <- base::Sys.time()
[17:29:45.598]             {
[17:29:45.598]                 {
[17:29:45.598]                   {
[17:29:45.598]                     {
[17:29:45.598]                       base::local({
[17:29:45.598]                         has_future <- base::requireNamespace("future", 
[17:29:45.598]                           quietly = TRUE)
[17:29:45.598]                         if (has_future) {
[17:29:45.598]                           ns <- base::getNamespace("future")
[17:29:45.598]                           version <- ns[[".package"]][["version"]]
[17:29:45.598]                           if (is.null(version)) 
[17:29:45.598]                             version <- utils::packageVersion("future")
[17:29:45.598]                         }
[17:29:45.598]                         else {
[17:29:45.598]                           version <- NULL
[17:29:45.598]                         }
[17:29:45.598]                         if (!has_future || version < "1.8.0") {
[17:29:45.598]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:45.598]                             "", base::R.version$version.string), 
[17:29:45.598]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:45.598]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:45.598]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:45.598]                               "release", "version")], collapse = " "), 
[17:29:45.598]                             hostname = base::Sys.info()[["nodename"]])
[17:29:45.598]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:45.598]                             info)
[17:29:45.598]                           info <- base::paste(info, collapse = "; ")
[17:29:45.598]                           if (!has_future) {
[17:29:45.598]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:45.598]                               info)
[17:29:45.598]                           }
[17:29:45.598]                           else {
[17:29:45.598]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:45.598]                               info, version)
[17:29:45.598]                           }
[17:29:45.598]                           base::stop(msg)
[17:29:45.598]                         }
[17:29:45.598]                       })
[17:29:45.598]                     }
[17:29:45.598]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:45.598]                     base::options(mc.cores = 1L)
[17:29:45.598]                   }
[17:29:45.598]                   ...future.strategy.old <- future::plan("list")
[17:29:45.598]                   options(future.plan = NULL)
[17:29:45.598]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.598]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:45.598]                 }
[17:29:45.598]                 ...future.workdir <- getwd()
[17:29:45.598]             }
[17:29:45.598]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:45.598]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:45.598]         }
[17:29:45.598]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:45.598]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:45.598]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:45.598]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:45.598]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:45.598]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:45.598]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:45.598]             base::names(...future.oldOptions))
[17:29:45.598]     }
[17:29:45.598]     if (FALSE) {
[17:29:45.598]     }
[17:29:45.598]     else {
[17:29:45.598]         if (TRUE) {
[17:29:45.598]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:45.598]                 open = "w")
[17:29:45.598]         }
[17:29:45.598]         else {
[17:29:45.598]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:45.598]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:45.598]         }
[17:29:45.598]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:45.598]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:45.598]             base::sink(type = "output", split = FALSE)
[17:29:45.598]             base::close(...future.stdout)
[17:29:45.598]         }, add = TRUE)
[17:29:45.598]     }
[17:29:45.598]     ...future.frame <- base::sys.nframe()
[17:29:45.598]     ...future.conditions <- base::list()
[17:29:45.598]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:45.598]     if (FALSE) {
[17:29:45.598]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:45.598]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:45.598]     }
[17:29:45.598]     ...future.result <- base::tryCatch({
[17:29:45.598]         base::withCallingHandlers({
[17:29:45.598]             ...future.value <- base::withVisible(base::local({
[17:29:45.598]                 ...future.makeSendCondition <- base::local({
[17:29:45.598]                   sendCondition <- NULL
[17:29:45.598]                   function(frame = 1L) {
[17:29:45.598]                     if (is.function(sendCondition)) 
[17:29:45.598]                       return(sendCondition)
[17:29:45.598]                     ns <- getNamespace("parallel")
[17:29:45.598]                     if (exists("sendData", mode = "function", 
[17:29:45.598]                       envir = ns)) {
[17:29:45.598]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:45.598]                         envir = ns)
[17:29:45.598]                       envir <- sys.frame(frame)
[17:29:45.598]                       master <- NULL
[17:29:45.598]                       while (!identical(envir, .GlobalEnv) && 
[17:29:45.598]                         !identical(envir, emptyenv())) {
[17:29:45.598]                         if (exists("master", mode = "list", envir = envir, 
[17:29:45.598]                           inherits = FALSE)) {
[17:29:45.598]                           master <- get("master", mode = "list", 
[17:29:45.598]                             envir = envir, inherits = FALSE)
[17:29:45.598]                           if (inherits(master, c("SOCKnode", 
[17:29:45.598]                             "SOCK0node"))) {
[17:29:45.598]                             sendCondition <<- function(cond) {
[17:29:45.598]                               data <- list(type = "VALUE", value = cond, 
[17:29:45.598]                                 success = TRUE)
[17:29:45.598]                               parallel_sendData(master, data)
[17:29:45.598]                             }
[17:29:45.598]                             return(sendCondition)
[17:29:45.598]                           }
[17:29:45.598]                         }
[17:29:45.598]                         frame <- frame + 1L
[17:29:45.598]                         envir <- sys.frame(frame)
[17:29:45.598]                       }
[17:29:45.598]                     }
[17:29:45.598]                     sendCondition <<- function(cond) NULL
[17:29:45.598]                   }
[17:29:45.598]                 })
[17:29:45.598]                 withCallingHandlers({
[17:29:45.598]                   {
[17:29:45.598]                     sample(x, size = 1L)
[17:29:45.598]                   }
[17:29:45.598]                 }, immediateCondition = function(cond) {
[17:29:45.598]                   sendCondition <- ...future.makeSendCondition()
[17:29:45.598]                   sendCondition(cond)
[17:29:45.598]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.598]                   {
[17:29:45.598]                     inherits <- base::inherits
[17:29:45.598]                     invokeRestart <- base::invokeRestart
[17:29:45.598]                     is.null <- base::is.null
[17:29:45.598]                     muffled <- FALSE
[17:29:45.598]                     if (inherits(cond, "message")) {
[17:29:45.598]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:45.598]                       if (muffled) 
[17:29:45.598]                         invokeRestart("muffleMessage")
[17:29:45.598]                     }
[17:29:45.598]                     else if (inherits(cond, "warning")) {
[17:29:45.598]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:45.598]                       if (muffled) 
[17:29:45.598]                         invokeRestart("muffleWarning")
[17:29:45.598]                     }
[17:29:45.598]                     else if (inherits(cond, "condition")) {
[17:29:45.598]                       if (!is.null(pattern)) {
[17:29:45.598]                         computeRestarts <- base::computeRestarts
[17:29:45.598]                         grepl <- base::grepl
[17:29:45.598]                         restarts <- computeRestarts(cond)
[17:29:45.598]                         for (restart in restarts) {
[17:29:45.598]                           name <- restart$name
[17:29:45.598]                           if (is.null(name)) 
[17:29:45.598]                             next
[17:29:45.598]                           if (!grepl(pattern, name)) 
[17:29:45.598]                             next
[17:29:45.598]                           invokeRestart(restart)
[17:29:45.598]                           muffled <- TRUE
[17:29:45.598]                           break
[17:29:45.598]                         }
[17:29:45.598]                       }
[17:29:45.598]                     }
[17:29:45.598]                     invisible(muffled)
[17:29:45.598]                   }
[17:29:45.598]                   muffleCondition(cond)
[17:29:45.598]                 })
[17:29:45.598]             }))
[17:29:45.598]             future::FutureResult(value = ...future.value$value, 
[17:29:45.598]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.598]                   ...future.rng), globalenv = if (FALSE) 
[17:29:45.598]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:45.598]                     ...future.globalenv.names))
[17:29:45.598]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:45.598]         }, condition = base::local({
[17:29:45.598]             c <- base::c
[17:29:45.598]             inherits <- base::inherits
[17:29:45.598]             invokeRestart <- base::invokeRestart
[17:29:45.598]             length <- base::length
[17:29:45.598]             list <- base::list
[17:29:45.598]             seq.int <- base::seq.int
[17:29:45.598]             signalCondition <- base::signalCondition
[17:29:45.598]             sys.calls <- base::sys.calls
[17:29:45.598]             `[[` <- base::`[[`
[17:29:45.598]             `+` <- base::`+`
[17:29:45.598]             `<<-` <- base::`<<-`
[17:29:45.598]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:45.598]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:45.598]                   3L)]
[17:29:45.598]             }
[17:29:45.598]             function(cond) {
[17:29:45.598]                 is_error <- inherits(cond, "error")
[17:29:45.598]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:45.598]                   NULL)
[17:29:45.598]                 if (is_error) {
[17:29:45.598]                   sessionInformation <- function() {
[17:29:45.598]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:45.598]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:45.598]                       search = base::search(), system = base::Sys.info())
[17:29:45.598]                   }
[17:29:45.598]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.598]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:45.598]                     cond$call), session = sessionInformation(), 
[17:29:45.598]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:45.598]                   signalCondition(cond)
[17:29:45.598]                 }
[17:29:45.598]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:45.598]                 "immediateCondition"))) {
[17:29:45.598]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:45.598]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.598]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:45.598]                   if (TRUE && !signal) {
[17:29:45.598]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.598]                     {
[17:29:45.598]                       inherits <- base::inherits
[17:29:45.598]                       invokeRestart <- base::invokeRestart
[17:29:45.598]                       is.null <- base::is.null
[17:29:45.598]                       muffled <- FALSE
[17:29:45.598]                       if (inherits(cond, "message")) {
[17:29:45.598]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.598]                         if (muffled) 
[17:29:45.598]                           invokeRestart("muffleMessage")
[17:29:45.598]                       }
[17:29:45.598]                       else if (inherits(cond, "warning")) {
[17:29:45.598]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.598]                         if (muffled) 
[17:29:45.598]                           invokeRestart("muffleWarning")
[17:29:45.598]                       }
[17:29:45.598]                       else if (inherits(cond, "condition")) {
[17:29:45.598]                         if (!is.null(pattern)) {
[17:29:45.598]                           computeRestarts <- base::computeRestarts
[17:29:45.598]                           grepl <- base::grepl
[17:29:45.598]                           restarts <- computeRestarts(cond)
[17:29:45.598]                           for (restart in restarts) {
[17:29:45.598]                             name <- restart$name
[17:29:45.598]                             if (is.null(name)) 
[17:29:45.598]                               next
[17:29:45.598]                             if (!grepl(pattern, name)) 
[17:29:45.598]                               next
[17:29:45.598]                             invokeRestart(restart)
[17:29:45.598]                             muffled <- TRUE
[17:29:45.598]                             break
[17:29:45.598]                           }
[17:29:45.598]                         }
[17:29:45.598]                       }
[17:29:45.598]                       invisible(muffled)
[17:29:45.598]                     }
[17:29:45.598]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.598]                   }
[17:29:45.598]                 }
[17:29:45.598]                 else {
[17:29:45.598]                   if (TRUE) {
[17:29:45.598]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.598]                     {
[17:29:45.598]                       inherits <- base::inherits
[17:29:45.598]                       invokeRestart <- base::invokeRestart
[17:29:45.598]                       is.null <- base::is.null
[17:29:45.598]                       muffled <- FALSE
[17:29:45.598]                       if (inherits(cond, "message")) {
[17:29:45.598]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.598]                         if (muffled) 
[17:29:45.598]                           invokeRestart("muffleMessage")
[17:29:45.598]                       }
[17:29:45.598]                       else if (inherits(cond, "warning")) {
[17:29:45.598]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.598]                         if (muffled) 
[17:29:45.598]                           invokeRestart("muffleWarning")
[17:29:45.598]                       }
[17:29:45.598]                       else if (inherits(cond, "condition")) {
[17:29:45.598]                         if (!is.null(pattern)) {
[17:29:45.598]                           computeRestarts <- base::computeRestarts
[17:29:45.598]                           grepl <- base::grepl
[17:29:45.598]                           restarts <- computeRestarts(cond)
[17:29:45.598]                           for (restart in restarts) {
[17:29:45.598]                             name <- restart$name
[17:29:45.598]                             if (is.null(name)) 
[17:29:45.598]                               next
[17:29:45.598]                             if (!grepl(pattern, name)) 
[17:29:45.598]                               next
[17:29:45.598]                             invokeRestart(restart)
[17:29:45.598]                             muffled <- TRUE
[17:29:45.598]                             break
[17:29:45.598]                           }
[17:29:45.598]                         }
[17:29:45.598]                       }
[17:29:45.598]                       invisible(muffled)
[17:29:45.598]                     }
[17:29:45.598]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.598]                   }
[17:29:45.598]                 }
[17:29:45.598]             }
[17:29:45.598]         }))
[17:29:45.598]     }, error = function(ex) {
[17:29:45.598]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:45.598]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.598]                 ...future.rng), started = ...future.startTime, 
[17:29:45.598]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:45.598]             version = "1.8"), class = "FutureResult")
[17:29:45.598]     }, finally = {
[17:29:45.598]         if (!identical(...future.workdir, getwd())) 
[17:29:45.598]             setwd(...future.workdir)
[17:29:45.598]         {
[17:29:45.598]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:45.598]                 ...future.oldOptions$nwarnings <- NULL
[17:29:45.598]             }
[17:29:45.598]             base::options(...future.oldOptions)
[17:29:45.598]             if (.Platform$OS.type == "windows") {
[17:29:45.598]                 old_names <- names(...future.oldEnvVars)
[17:29:45.598]                 envs <- base::Sys.getenv()
[17:29:45.598]                 names <- names(envs)
[17:29:45.598]                 common <- intersect(names, old_names)
[17:29:45.598]                 added <- setdiff(names, old_names)
[17:29:45.598]                 removed <- setdiff(old_names, names)
[17:29:45.598]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:45.598]                   envs[common]]
[17:29:45.598]                 NAMES <- toupper(changed)
[17:29:45.598]                 args <- list()
[17:29:45.598]                 for (kk in seq_along(NAMES)) {
[17:29:45.598]                   name <- changed[[kk]]
[17:29:45.598]                   NAME <- NAMES[[kk]]
[17:29:45.598]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.598]                     next
[17:29:45.598]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.598]                 }
[17:29:45.598]                 NAMES <- toupper(added)
[17:29:45.598]                 for (kk in seq_along(NAMES)) {
[17:29:45.598]                   name <- added[[kk]]
[17:29:45.598]                   NAME <- NAMES[[kk]]
[17:29:45.598]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.598]                     next
[17:29:45.598]                   args[[name]] <- ""
[17:29:45.598]                 }
[17:29:45.598]                 NAMES <- toupper(removed)
[17:29:45.598]                 for (kk in seq_along(NAMES)) {
[17:29:45.598]                   name <- removed[[kk]]
[17:29:45.598]                   NAME <- NAMES[[kk]]
[17:29:45.598]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.598]                     next
[17:29:45.598]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.598]                 }
[17:29:45.598]                 if (length(args) > 0) 
[17:29:45.598]                   base::do.call(base::Sys.setenv, args = args)
[17:29:45.598]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:45.598]             }
[17:29:45.598]             else {
[17:29:45.598]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:45.598]             }
[17:29:45.598]             {
[17:29:45.598]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:45.598]                   0L) {
[17:29:45.598]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:45.598]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:45.598]                   base::options(opts)
[17:29:45.598]                 }
[17:29:45.598]                 {
[17:29:45.598]                   {
[17:29:45.598]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:45.598]                     NULL
[17:29:45.598]                   }
[17:29:45.598]                   options(future.plan = NULL)
[17:29:45.598]                   if (is.na(NA_character_)) 
[17:29:45.598]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.598]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:45.598]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:45.598]                     .init = FALSE)
[17:29:45.598]                 }
[17:29:45.598]             }
[17:29:45.598]         }
[17:29:45.598]     })
[17:29:45.598]     if (TRUE) {
[17:29:45.598]         base::sink(type = "output", split = FALSE)
[17:29:45.598]         if (TRUE) {
[17:29:45.598]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:45.598]         }
[17:29:45.598]         else {
[17:29:45.598]             ...future.result["stdout"] <- base::list(NULL)
[17:29:45.598]         }
[17:29:45.598]         base::close(...future.stdout)
[17:29:45.598]         ...future.stdout <- NULL
[17:29:45.598]     }
[17:29:45.598]     ...future.result$conditions <- ...future.conditions
[17:29:45.598]     ...future.result$finished <- base::Sys.time()
[17:29:45.598]     ...future.result
[17:29:45.598] }
[17:29:45.604] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:45.605] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:45.605] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:45.606] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:45.606] MultisessionFuture started
[17:29:45.607] - Launch lazy future ... done
[17:29:45.607] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_1-757701'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001addaa98c70
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:29:45.628] receiveMessageFromWorker() for ClusterFuture ...
[17:29:45.628] - Validating connection of MultisessionFuture
[17:29:45.629] - received message: FutureResult
[17:29:45.629] - Received FutureResult
[17:29:45.629] - Erased future from FutureRegistry
[17:29:45.630] result() for ClusterFuture ...
[17:29:45.630] - result already collected: FutureResult
[17:29:45.630] result() for ClusterFuture ... done
[17:29:45.630] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.630] getGlobalsAndPackages() ...
[17:29:45.631] Searching for globals...
[17:29:45.632] - globals found: [3] '{', 'sample', 'x'
[17:29:45.632] Searching for globals ... DONE
[17:29:45.632] Resolving globals: FALSE
[17:29:45.633] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:45.634] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:45.634] - globals: [1] 'x'
[17:29:45.634] 
[17:29:45.635] getGlobalsAndPackages() ... DONE
[17:29:45.635] run() for 'Future' ...
[17:29:45.635] - state: 'created'
[17:29:45.635] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:45.652] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.653] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:45.653]   - Field: 'node'
[17:29:45.654]   - Field: 'label'
[17:29:45.654]   - Field: 'local'
[17:29:45.654]   - Field: 'owner'
[17:29:45.655]   - Field: 'envir'
[17:29:45.655]   - Field: 'workers'
[17:29:45.655]   - Field: 'packages'
[17:29:45.656]   - Field: 'gc'
[17:29:45.656]   - Field: 'conditions'
[17:29:45.656]   - Field: 'persistent'
[17:29:45.657]   - Field: 'expr'
[17:29:45.657]   - Field: 'uuid'
[17:29:45.657]   - Field: 'seed'
[17:29:45.658]   - Field: 'version'
[17:29:45.658]   - Field: 'result'
[17:29:45.658]   - Field: 'asynchronous'
[17:29:45.659]   - Field: 'calls'
[17:29:45.659]   - Field: 'globals'
[17:29:45.659]   - Field: 'stdout'
[17:29:45.660]   - Field: 'earlySignal'
[17:29:45.660]   - Field: 'lazy'
[17:29:45.660]   - Field: 'state'
[17:29:45.661] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:45.661] - Launch lazy future ...
[17:29:45.662] Packages needed by the future expression (n = 0): <none>
[17:29:45.662] Packages needed by future strategies (n = 0): <none>
[17:29:45.663] {
[17:29:45.663]     {
[17:29:45.663]         {
[17:29:45.663]             ...future.startTime <- base::Sys.time()
[17:29:45.663]             {
[17:29:45.663]                 {
[17:29:45.663]                   {
[17:29:45.663]                     {
[17:29:45.663]                       base::local({
[17:29:45.663]                         has_future <- base::requireNamespace("future", 
[17:29:45.663]                           quietly = TRUE)
[17:29:45.663]                         if (has_future) {
[17:29:45.663]                           ns <- base::getNamespace("future")
[17:29:45.663]                           version <- ns[[".package"]][["version"]]
[17:29:45.663]                           if (is.null(version)) 
[17:29:45.663]                             version <- utils::packageVersion("future")
[17:29:45.663]                         }
[17:29:45.663]                         else {
[17:29:45.663]                           version <- NULL
[17:29:45.663]                         }
[17:29:45.663]                         if (!has_future || version < "1.8.0") {
[17:29:45.663]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:45.663]                             "", base::R.version$version.string), 
[17:29:45.663]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:45.663]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:45.663]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:45.663]                               "release", "version")], collapse = " "), 
[17:29:45.663]                             hostname = base::Sys.info()[["nodename"]])
[17:29:45.663]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:45.663]                             info)
[17:29:45.663]                           info <- base::paste(info, collapse = "; ")
[17:29:45.663]                           if (!has_future) {
[17:29:45.663]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:45.663]                               info)
[17:29:45.663]                           }
[17:29:45.663]                           else {
[17:29:45.663]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:45.663]                               info, version)
[17:29:45.663]                           }
[17:29:45.663]                           base::stop(msg)
[17:29:45.663]                         }
[17:29:45.663]                       })
[17:29:45.663]                     }
[17:29:45.663]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:45.663]                     base::options(mc.cores = 1L)
[17:29:45.663]                   }
[17:29:45.663]                   ...future.strategy.old <- future::plan("list")
[17:29:45.663]                   options(future.plan = NULL)
[17:29:45.663]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.663]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:45.663]                 }
[17:29:45.663]                 ...future.workdir <- getwd()
[17:29:45.663]             }
[17:29:45.663]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:45.663]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:45.663]         }
[17:29:45.663]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:45.663]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:45.663]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:45.663]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:45.663]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:45.663]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:45.663]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:45.663]             base::names(...future.oldOptions))
[17:29:45.663]     }
[17:29:45.663]     if (FALSE) {
[17:29:45.663]     }
[17:29:45.663]     else {
[17:29:45.663]         if (TRUE) {
[17:29:45.663]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:45.663]                 open = "w")
[17:29:45.663]         }
[17:29:45.663]         else {
[17:29:45.663]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:45.663]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:45.663]         }
[17:29:45.663]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:45.663]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:45.663]             base::sink(type = "output", split = FALSE)
[17:29:45.663]             base::close(...future.stdout)
[17:29:45.663]         }, add = TRUE)
[17:29:45.663]     }
[17:29:45.663]     ...future.frame <- base::sys.nframe()
[17:29:45.663]     ...future.conditions <- base::list()
[17:29:45.663]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:45.663]     if (FALSE) {
[17:29:45.663]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:45.663]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:45.663]     }
[17:29:45.663]     ...future.result <- base::tryCatch({
[17:29:45.663]         base::withCallingHandlers({
[17:29:45.663]             ...future.value <- base::withVisible(base::local({
[17:29:45.663]                 ...future.makeSendCondition <- base::local({
[17:29:45.663]                   sendCondition <- NULL
[17:29:45.663]                   function(frame = 1L) {
[17:29:45.663]                     if (is.function(sendCondition)) 
[17:29:45.663]                       return(sendCondition)
[17:29:45.663]                     ns <- getNamespace("parallel")
[17:29:45.663]                     if (exists("sendData", mode = "function", 
[17:29:45.663]                       envir = ns)) {
[17:29:45.663]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:45.663]                         envir = ns)
[17:29:45.663]                       envir <- sys.frame(frame)
[17:29:45.663]                       master <- NULL
[17:29:45.663]                       while (!identical(envir, .GlobalEnv) && 
[17:29:45.663]                         !identical(envir, emptyenv())) {
[17:29:45.663]                         if (exists("master", mode = "list", envir = envir, 
[17:29:45.663]                           inherits = FALSE)) {
[17:29:45.663]                           master <- get("master", mode = "list", 
[17:29:45.663]                             envir = envir, inherits = FALSE)
[17:29:45.663]                           if (inherits(master, c("SOCKnode", 
[17:29:45.663]                             "SOCK0node"))) {
[17:29:45.663]                             sendCondition <<- function(cond) {
[17:29:45.663]                               data <- list(type = "VALUE", value = cond, 
[17:29:45.663]                                 success = TRUE)
[17:29:45.663]                               parallel_sendData(master, data)
[17:29:45.663]                             }
[17:29:45.663]                             return(sendCondition)
[17:29:45.663]                           }
[17:29:45.663]                         }
[17:29:45.663]                         frame <- frame + 1L
[17:29:45.663]                         envir <- sys.frame(frame)
[17:29:45.663]                       }
[17:29:45.663]                     }
[17:29:45.663]                     sendCondition <<- function(cond) NULL
[17:29:45.663]                   }
[17:29:45.663]                 })
[17:29:45.663]                 withCallingHandlers({
[17:29:45.663]                   {
[17:29:45.663]                     sample(x, size = 1L)
[17:29:45.663]                   }
[17:29:45.663]                 }, immediateCondition = function(cond) {
[17:29:45.663]                   sendCondition <- ...future.makeSendCondition()
[17:29:45.663]                   sendCondition(cond)
[17:29:45.663]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.663]                   {
[17:29:45.663]                     inherits <- base::inherits
[17:29:45.663]                     invokeRestart <- base::invokeRestart
[17:29:45.663]                     is.null <- base::is.null
[17:29:45.663]                     muffled <- FALSE
[17:29:45.663]                     if (inherits(cond, "message")) {
[17:29:45.663]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:45.663]                       if (muffled) 
[17:29:45.663]                         invokeRestart("muffleMessage")
[17:29:45.663]                     }
[17:29:45.663]                     else if (inherits(cond, "warning")) {
[17:29:45.663]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:45.663]                       if (muffled) 
[17:29:45.663]                         invokeRestart("muffleWarning")
[17:29:45.663]                     }
[17:29:45.663]                     else if (inherits(cond, "condition")) {
[17:29:45.663]                       if (!is.null(pattern)) {
[17:29:45.663]                         computeRestarts <- base::computeRestarts
[17:29:45.663]                         grepl <- base::grepl
[17:29:45.663]                         restarts <- computeRestarts(cond)
[17:29:45.663]                         for (restart in restarts) {
[17:29:45.663]                           name <- restart$name
[17:29:45.663]                           if (is.null(name)) 
[17:29:45.663]                             next
[17:29:45.663]                           if (!grepl(pattern, name)) 
[17:29:45.663]                             next
[17:29:45.663]                           invokeRestart(restart)
[17:29:45.663]                           muffled <- TRUE
[17:29:45.663]                           break
[17:29:45.663]                         }
[17:29:45.663]                       }
[17:29:45.663]                     }
[17:29:45.663]                     invisible(muffled)
[17:29:45.663]                   }
[17:29:45.663]                   muffleCondition(cond)
[17:29:45.663]                 })
[17:29:45.663]             }))
[17:29:45.663]             future::FutureResult(value = ...future.value$value, 
[17:29:45.663]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.663]                   ...future.rng), globalenv = if (FALSE) 
[17:29:45.663]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:45.663]                     ...future.globalenv.names))
[17:29:45.663]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:45.663]         }, condition = base::local({
[17:29:45.663]             c <- base::c
[17:29:45.663]             inherits <- base::inherits
[17:29:45.663]             invokeRestart <- base::invokeRestart
[17:29:45.663]             length <- base::length
[17:29:45.663]             list <- base::list
[17:29:45.663]             seq.int <- base::seq.int
[17:29:45.663]             signalCondition <- base::signalCondition
[17:29:45.663]             sys.calls <- base::sys.calls
[17:29:45.663]             `[[` <- base::`[[`
[17:29:45.663]             `+` <- base::`+`
[17:29:45.663]             `<<-` <- base::`<<-`
[17:29:45.663]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:45.663]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:45.663]                   3L)]
[17:29:45.663]             }
[17:29:45.663]             function(cond) {
[17:29:45.663]                 is_error <- inherits(cond, "error")
[17:29:45.663]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:45.663]                   NULL)
[17:29:45.663]                 if (is_error) {
[17:29:45.663]                   sessionInformation <- function() {
[17:29:45.663]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:45.663]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:45.663]                       search = base::search(), system = base::Sys.info())
[17:29:45.663]                   }
[17:29:45.663]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.663]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:45.663]                     cond$call), session = sessionInformation(), 
[17:29:45.663]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:45.663]                   signalCondition(cond)
[17:29:45.663]                 }
[17:29:45.663]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:45.663]                 "immediateCondition"))) {
[17:29:45.663]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:45.663]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.663]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:45.663]                   if (TRUE && !signal) {
[17:29:45.663]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.663]                     {
[17:29:45.663]                       inherits <- base::inherits
[17:29:45.663]                       invokeRestart <- base::invokeRestart
[17:29:45.663]                       is.null <- base::is.null
[17:29:45.663]                       muffled <- FALSE
[17:29:45.663]                       if (inherits(cond, "message")) {
[17:29:45.663]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.663]                         if (muffled) 
[17:29:45.663]                           invokeRestart("muffleMessage")
[17:29:45.663]                       }
[17:29:45.663]                       else if (inherits(cond, "warning")) {
[17:29:45.663]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.663]                         if (muffled) 
[17:29:45.663]                           invokeRestart("muffleWarning")
[17:29:45.663]                       }
[17:29:45.663]                       else if (inherits(cond, "condition")) {
[17:29:45.663]                         if (!is.null(pattern)) {
[17:29:45.663]                           computeRestarts <- base::computeRestarts
[17:29:45.663]                           grepl <- base::grepl
[17:29:45.663]                           restarts <- computeRestarts(cond)
[17:29:45.663]                           for (restart in restarts) {
[17:29:45.663]                             name <- restart$name
[17:29:45.663]                             if (is.null(name)) 
[17:29:45.663]                               next
[17:29:45.663]                             if (!grepl(pattern, name)) 
[17:29:45.663]                               next
[17:29:45.663]                             invokeRestart(restart)
[17:29:45.663]                             muffled <- TRUE
[17:29:45.663]                             break
[17:29:45.663]                           }
[17:29:45.663]                         }
[17:29:45.663]                       }
[17:29:45.663]                       invisible(muffled)
[17:29:45.663]                     }
[17:29:45.663]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.663]                   }
[17:29:45.663]                 }
[17:29:45.663]                 else {
[17:29:45.663]                   if (TRUE) {
[17:29:45.663]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.663]                     {
[17:29:45.663]                       inherits <- base::inherits
[17:29:45.663]                       invokeRestart <- base::invokeRestart
[17:29:45.663]                       is.null <- base::is.null
[17:29:45.663]                       muffled <- FALSE
[17:29:45.663]                       if (inherits(cond, "message")) {
[17:29:45.663]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.663]                         if (muffled) 
[17:29:45.663]                           invokeRestart("muffleMessage")
[17:29:45.663]                       }
[17:29:45.663]                       else if (inherits(cond, "warning")) {
[17:29:45.663]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.663]                         if (muffled) 
[17:29:45.663]                           invokeRestart("muffleWarning")
[17:29:45.663]                       }
[17:29:45.663]                       else if (inherits(cond, "condition")) {
[17:29:45.663]                         if (!is.null(pattern)) {
[17:29:45.663]                           computeRestarts <- base::computeRestarts
[17:29:45.663]                           grepl <- base::grepl
[17:29:45.663]                           restarts <- computeRestarts(cond)
[17:29:45.663]                           for (restart in restarts) {
[17:29:45.663]                             name <- restart$name
[17:29:45.663]                             if (is.null(name)) 
[17:29:45.663]                               next
[17:29:45.663]                             if (!grepl(pattern, name)) 
[17:29:45.663]                               next
[17:29:45.663]                             invokeRestart(restart)
[17:29:45.663]                             muffled <- TRUE
[17:29:45.663]                             break
[17:29:45.663]                           }
[17:29:45.663]                         }
[17:29:45.663]                       }
[17:29:45.663]                       invisible(muffled)
[17:29:45.663]                     }
[17:29:45.663]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.663]                   }
[17:29:45.663]                 }
[17:29:45.663]             }
[17:29:45.663]         }))
[17:29:45.663]     }, error = function(ex) {
[17:29:45.663]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:45.663]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.663]                 ...future.rng), started = ...future.startTime, 
[17:29:45.663]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:45.663]             version = "1.8"), class = "FutureResult")
[17:29:45.663]     }, finally = {
[17:29:45.663]         if (!identical(...future.workdir, getwd())) 
[17:29:45.663]             setwd(...future.workdir)
[17:29:45.663]         {
[17:29:45.663]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:45.663]                 ...future.oldOptions$nwarnings <- NULL
[17:29:45.663]             }
[17:29:45.663]             base::options(...future.oldOptions)
[17:29:45.663]             if (.Platform$OS.type == "windows") {
[17:29:45.663]                 old_names <- names(...future.oldEnvVars)
[17:29:45.663]                 envs <- base::Sys.getenv()
[17:29:45.663]                 names <- names(envs)
[17:29:45.663]                 common <- intersect(names, old_names)
[17:29:45.663]                 added <- setdiff(names, old_names)
[17:29:45.663]                 removed <- setdiff(old_names, names)
[17:29:45.663]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:45.663]                   envs[common]]
[17:29:45.663]                 NAMES <- toupper(changed)
[17:29:45.663]                 args <- list()
[17:29:45.663]                 for (kk in seq_along(NAMES)) {
[17:29:45.663]                   name <- changed[[kk]]
[17:29:45.663]                   NAME <- NAMES[[kk]]
[17:29:45.663]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.663]                     next
[17:29:45.663]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.663]                 }
[17:29:45.663]                 NAMES <- toupper(added)
[17:29:45.663]                 for (kk in seq_along(NAMES)) {
[17:29:45.663]                   name <- added[[kk]]
[17:29:45.663]                   NAME <- NAMES[[kk]]
[17:29:45.663]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.663]                     next
[17:29:45.663]                   args[[name]] <- ""
[17:29:45.663]                 }
[17:29:45.663]                 NAMES <- toupper(removed)
[17:29:45.663]                 for (kk in seq_along(NAMES)) {
[17:29:45.663]                   name <- removed[[kk]]
[17:29:45.663]                   NAME <- NAMES[[kk]]
[17:29:45.663]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.663]                     next
[17:29:45.663]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.663]                 }
[17:29:45.663]                 if (length(args) > 0) 
[17:29:45.663]                   base::do.call(base::Sys.setenv, args = args)
[17:29:45.663]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:45.663]             }
[17:29:45.663]             else {
[17:29:45.663]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:45.663]             }
[17:29:45.663]             {
[17:29:45.663]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:45.663]                   0L) {
[17:29:45.663]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:45.663]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:45.663]                   base::options(opts)
[17:29:45.663]                 }
[17:29:45.663]                 {
[17:29:45.663]                   {
[17:29:45.663]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:45.663]                     NULL
[17:29:45.663]                   }
[17:29:45.663]                   options(future.plan = NULL)
[17:29:45.663]                   if (is.na(NA_character_)) 
[17:29:45.663]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.663]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:45.663]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:45.663]                     .init = FALSE)
[17:29:45.663]                 }
[17:29:45.663]             }
[17:29:45.663]         }
[17:29:45.663]     })
[17:29:45.663]     if (TRUE) {
[17:29:45.663]         base::sink(type = "output", split = FALSE)
[17:29:45.663]         if (TRUE) {
[17:29:45.663]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:45.663]         }
[17:29:45.663]         else {
[17:29:45.663]             ...future.result["stdout"] <- base::list(NULL)
[17:29:45.663]         }
[17:29:45.663]         base::close(...future.stdout)
[17:29:45.663]         ...future.stdout <- NULL
[17:29:45.663]     }
[17:29:45.663]     ...future.result$conditions <- ...future.conditions
[17:29:45.663]     ...future.result$finished <- base::Sys.time()
[17:29:45.663]     ...future.result
[17:29:45.663] }
[17:29:45.672] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:45.672] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:45.673] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:45.673] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:45.674] MultisessionFuture started
[17:29:45.674] - Launch lazy future ... done
[17:29:45.674] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_2-177304'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001addaa98c70
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:29:45.689] receiveMessageFromWorker() for ClusterFuture ...
[17:29:45.690] - Validating connection of MultisessionFuture
[17:29:45.690] - received message: FutureResult
[17:29:45.690] - Received FutureResult
[17:29:45.691] - Erased future from FutureRegistry
[17:29:45.691] result() for ClusterFuture ...
[17:29:45.691] - result already collected: FutureResult
[17:29:45.691] result() for ClusterFuture ... done
[17:29:45.692] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.692] getGlobalsAndPackages() ...
[17:29:45.692] Searching for globals...
[17:29:45.695] - globals found: [3] '{', 'sample', 'x'
[17:29:45.695] Searching for globals ... DONE
[17:29:45.695] Resolving globals: FALSE
[17:29:45.696] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:45.697] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:45.697] - globals: [1] 'x'
[17:29:45.697] 
[17:29:45.697] getGlobalsAndPackages() ... DONE
[17:29:45.698] run() for 'Future' ...
[17:29:45.698] - state: 'created'
[17:29:45.699] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:45.718] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.719] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:45.719]   - Field: 'node'
[17:29:45.719]   - Field: 'label'
[17:29:45.720]   - Field: 'local'
[17:29:45.720]   - Field: 'owner'
[17:29:45.720]   - Field: 'envir'
[17:29:45.720]   - Field: 'workers'
[17:29:45.721]   - Field: 'packages'
[17:29:45.721]   - Field: 'gc'
[17:29:45.721]   - Field: 'conditions'
[17:29:45.722]   - Field: 'persistent'
[17:29:45.722]   - Field: 'expr'
[17:29:45.722]   - Field: 'uuid'
[17:29:45.722]   - Field: 'seed'
[17:29:45.723]   - Field: 'version'
[17:29:45.723]   - Field: 'result'
[17:29:45.724]   - Field: 'asynchronous'
[17:29:45.724]   - Field: 'calls'
[17:29:45.724]   - Field: 'globals'
[17:29:45.725]   - Field: 'stdout'
[17:29:45.725]   - Field: 'earlySignal'
[17:29:45.725]   - Field: 'lazy'
[17:29:45.726]   - Field: 'state'
[17:29:45.726] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:45.726] - Launch lazy future ...
[17:29:45.727] Packages needed by the future expression (n = 0): <none>
[17:29:45.727] Packages needed by future strategies (n = 0): <none>
[17:29:45.728] {
[17:29:45.728]     {
[17:29:45.728]         {
[17:29:45.728]             ...future.startTime <- base::Sys.time()
[17:29:45.728]             {
[17:29:45.728]                 {
[17:29:45.728]                   {
[17:29:45.728]                     {
[17:29:45.728]                       base::local({
[17:29:45.728]                         has_future <- base::requireNamespace("future", 
[17:29:45.728]                           quietly = TRUE)
[17:29:45.728]                         if (has_future) {
[17:29:45.728]                           ns <- base::getNamespace("future")
[17:29:45.728]                           version <- ns[[".package"]][["version"]]
[17:29:45.728]                           if (is.null(version)) 
[17:29:45.728]                             version <- utils::packageVersion("future")
[17:29:45.728]                         }
[17:29:45.728]                         else {
[17:29:45.728]                           version <- NULL
[17:29:45.728]                         }
[17:29:45.728]                         if (!has_future || version < "1.8.0") {
[17:29:45.728]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:45.728]                             "", base::R.version$version.string), 
[17:29:45.728]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:45.728]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:45.728]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:45.728]                               "release", "version")], collapse = " "), 
[17:29:45.728]                             hostname = base::Sys.info()[["nodename"]])
[17:29:45.728]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:45.728]                             info)
[17:29:45.728]                           info <- base::paste(info, collapse = "; ")
[17:29:45.728]                           if (!has_future) {
[17:29:45.728]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:45.728]                               info)
[17:29:45.728]                           }
[17:29:45.728]                           else {
[17:29:45.728]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:45.728]                               info, version)
[17:29:45.728]                           }
[17:29:45.728]                           base::stop(msg)
[17:29:45.728]                         }
[17:29:45.728]                       })
[17:29:45.728]                     }
[17:29:45.728]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:45.728]                     base::options(mc.cores = 1L)
[17:29:45.728]                   }
[17:29:45.728]                   ...future.strategy.old <- future::plan("list")
[17:29:45.728]                   options(future.plan = NULL)
[17:29:45.728]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.728]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:45.728]                 }
[17:29:45.728]                 ...future.workdir <- getwd()
[17:29:45.728]             }
[17:29:45.728]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:45.728]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:45.728]         }
[17:29:45.728]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:45.728]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:45.728]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:45.728]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:45.728]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:45.728]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:45.728]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:45.728]             base::names(...future.oldOptions))
[17:29:45.728]     }
[17:29:45.728]     if (FALSE) {
[17:29:45.728]     }
[17:29:45.728]     else {
[17:29:45.728]         if (TRUE) {
[17:29:45.728]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:45.728]                 open = "w")
[17:29:45.728]         }
[17:29:45.728]         else {
[17:29:45.728]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:45.728]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:45.728]         }
[17:29:45.728]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:45.728]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:45.728]             base::sink(type = "output", split = FALSE)
[17:29:45.728]             base::close(...future.stdout)
[17:29:45.728]         }, add = TRUE)
[17:29:45.728]     }
[17:29:45.728]     ...future.frame <- base::sys.nframe()
[17:29:45.728]     ...future.conditions <- base::list()
[17:29:45.728]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:45.728]     if (FALSE) {
[17:29:45.728]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:45.728]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:45.728]     }
[17:29:45.728]     ...future.result <- base::tryCatch({
[17:29:45.728]         base::withCallingHandlers({
[17:29:45.728]             ...future.value <- base::withVisible(base::local({
[17:29:45.728]                 ...future.makeSendCondition <- base::local({
[17:29:45.728]                   sendCondition <- NULL
[17:29:45.728]                   function(frame = 1L) {
[17:29:45.728]                     if (is.function(sendCondition)) 
[17:29:45.728]                       return(sendCondition)
[17:29:45.728]                     ns <- getNamespace("parallel")
[17:29:45.728]                     if (exists("sendData", mode = "function", 
[17:29:45.728]                       envir = ns)) {
[17:29:45.728]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:45.728]                         envir = ns)
[17:29:45.728]                       envir <- sys.frame(frame)
[17:29:45.728]                       master <- NULL
[17:29:45.728]                       while (!identical(envir, .GlobalEnv) && 
[17:29:45.728]                         !identical(envir, emptyenv())) {
[17:29:45.728]                         if (exists("master", mode = "list", envir = envir, 
[17:29:45.728]                           inherits = FALSE)) {
[17:29:45.728]                           master <- get("master", mode = "list", 
[17:29:45.728]                             envir = envir, inherits = FALSE)
[17:29:45.728]                           if (inherits(master, c("SOCKnode", 
[17:29:45.728]                             "SOCK0node"))) {
[17:29:45.728]                             sendCondition <<- function(cond) {
[17:29:45.728]                               data <- list(type = "VALUE", value = cond, 
[17:29:45.728]                                 success = TRUE)
[17:29:45.728]                               parallel_sendData(master, data)
[17:29:45.728]                             }
[17:29:45.728]                             return(sendCondition)
[17:29:45.728]                           }
[17:29:45.728]                         }
[17:29:45.728]                         frame <- frame + 1L
[17:29:45.728]                         envir <- sys.frame(frame)
[17:29:45.728]                       }
[17:29:45.728]                     }
[17:29:45.728]                     sendCondition <<- function(cond) NULL
[17:29:45.728]                   }
[17:29:45.728]                 })
[17:29:45.728]                 withCallingHandlers({
[17:29:45.728]                   {
[17:29:45.728]                     sample(x, size = 1L)
[17:29:45.728]                   }
[17:29:45.728]                 }, immediateCondition = function(cond) {
[17:29:45.728]                   sendCondition <- ...future.makeSendCondition()
[17:29:45.728]                   sendCondition(cond)
[17:29:45.728]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.728]                   {
[17:29:45.728]                     inherits <- base::inherits
[17:29:45.728]                     invokeRestart <- base::invokeRestart
[17:29:45.728]                     is.null <- base::is.null
[17:29:45.728]                     muffled <- FALSE
[17:29:45.728]                     if (inherits(cond, "message")) {
[17:29:45.728]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:45.728]                       if (muffled) 
[17:29:45.728]                         invokeRestart("muffleMessage")
[17:29:45.728]                     }
[17:29:45.728]                     else if (inherits(cond, "warning")) {
[17:29:45.728]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:45.728]                       if (muffled) 
[17:29:45.728]                         invokeRestart("muffleWarning")
[17:29:45.728]                     }
[17:29:45.728]                     else if (inherits(cond, "condition")) {
[17:29:45.728]                       if (!is.null(pattern)) {
[17:29:45.728]                         computeRestarts <- base::computeRestarts
[17:29:45.728]                         grepl <- base::grepl
[17:29:45.728]                         restarts <- computeRestarts(cond)
[17:29:45.728]                         for (restart in restarts) {
[17:29:45.728]                           name <- restart$name
[17:29:45.728]                           if (is.null(name)) 
[17:29:45.728]                             next
[17:29:45.728]                           if (!grepl(pattern, name)) 
[17:29:45.728]                             next
[17:29:45.728]                           invokeRestart(restart)
[17:29:45.728]                           muffled <- TRUE
[17:29:45.728]                           break
[17:29:45.728]                         }
[17:29:45.728]                       }
[17:29:45.728]                     }
[17:29:45.728]                     invisible(muffled)
[17:29:45.728]                   }
[17:29:45.728]                   muffleCondition(cond)
[17:29:45.728]                 })
[17:29:45.728]             }))
[17:29:45.728]             future::FutureResult(value = ...future.value$value, 
[17:29:45.728]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.728]                   ...future.rng), globalenv = if (FALSE) 
[17:29:45.728]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:45.728]                     ...future.globalenv.names))
[17:29:45.728]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:45.728]         }, condition = base::local({
[17:29:45.728]             c <- base::c
[17:29:45.728]             inherits <- base::inherits
[17:29:45.728]             invokeRestart <- base::invokeRestart
[17:29:45.728]             length <- base::length
[17:29:45.728]             list <- base::list
[17:29:45.728]             seq.int <- base::seq.int
[17:29:45.728]             signalCondition <- base::signalCondition
[17:29:45.728]             sys.calls <- base::sys.calls
[17:29:45.728]             `[[` <- base::`[[`
[17:29:45.728]             `+` <- base::`+`
[17:29:45.728]             `<<-` <- base::`<<-`
[17:29:45.728]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:45.728]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:45.728]                   3L)]
[17:29:45.728]             }
[17:29:45.728]             function(cond) {
[17:29:45.728]                 is_error <- inherits(cond, "error")
[17:29:45.728]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:45.728]                   NULL)
[17:29:45.728]                 if (is_error) {
[17:29:45.728]                   sessionInformation <- function() {
[17:29:45.728]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:45.728]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:45.728]                       search = base::search(), system = base::Sys.info())
[17:29:45.728]                   }
[17:29:45.728]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.728]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:45.728]                     cond$call), session = sessionInformation(), 
[17:29:45.728]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:45.728]                   signalCondition(cond)
[17:29:45.728]                 }
[17:29:45.728]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:45.728]                 "immediateCondition"))) {
[17:29:45.728]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:45.728]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.728]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:45.728]                   if (TRUE && !signal) {
[17:29:45.728]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.728]                     {
[17:29:45.728]                       inherits <- base::inherits
[17:29:45.728]                       invokeRestart <- base::invokeRestart
[17:29:45.728]                       is.null <- base::is.null
[17:29:45.728]                       muffled <- FALSE
[17:29:45.728]                       if (inherits(cond, "message")) {
[17:29:45.728]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.728]                         if (muffled) 
[17:29:45.728]                           invokeRestart("muffleMessage")
[17:29:45.728]                       }
[17:29:45.728]                       else if (inherits(cond, "warning")) {
[17:29:45.728]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.728]                         if (muffled) 
[17:29:45.728]                           invokeRestart("muffleWarning")
[17:29:45.728]                       }
[17:29:45.728]                       else if (inherits(cond, "condition")) {
[17:29:45.728]                         if (!is.null(pattern)) {
[17:29:45.728]                           computeRestarts <- base::computeRestarts
[17:29:45.728]                           grepl <- base::grepl
[17:29:45.728]                           restarts <- computeRestarts(cond)
[17:29:45.728]                           for (restart in restarts) {
[17:29:45.728]                             name <- restart$name
[17:29:45.728]                             if (is.null(name)) 
[17:29:45.728]                               next
[17:29:45.728]                             if (!grepl(pattern, name)) 
[17:29:45.728]                               next
[17:29:45.728]                             invokeRestart(restart)
[17:29:45.728]                             muffled <- TRUE
[17:29:45.728]                             break
[17:29:45.728]                           }
[17:29:45.728]                         }
[17:29:45.728]                       }
[17:29:45.728]                       invisible(muffled)
[17:29:45.728]                     }
[17:29:45.728]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.728]                   }
[17:29:45.728]                 }
[17:29:45.728]                 else {
[17:29:45.728]                   if (TRUE) {
[17:29:45.728]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.728]                     {
[17:29:45.728]                       inherits <- base::inherits
[17:29:45.728]                       invokeRestart <- base::invokeRestart
[17:29:45.728]                       is.null <- base::is.null
[17:29:45.728]                       muffled <- FALSE
[17:29:45.728]                       if (inherits(cond, "message")) {
[17:29:45.728]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.728]                         if (muffled) 
[17:29:45.728]                           invokeRestart("muffleMessage")
[17:29:45.728]                       }
[17:29:45.728]                       else if (inherits(cond, "warning")) {
[17:29:45.728]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.728]                         if (muffled) 
[17:29:45.728]                           invokeRestart("muffleWarning")
[17:29:45.728]                       }
[17:29:45.728]                       else if (inherits(cond, "condition")) {
[17:29:45.728]                         if (!is.null(pattern)) {
[17:29:45.728]                           computeRestarts <- base::computeRestarts
[17:29:45.728]                           grepl <- base::grepl
[17:29:45.728]                           restarts <- computeRestarts(cond)
[17:29:45.728]                           for (restart in restarts) {
[17:29:45.728]                             name <- restart$name
[17:29:45.728]                             if (is.null(name)) 
[17:29:45.728]                               next
[17:29:45.728]                             if (!grepl(pattern, name)) 
[17:29:45.728]                               next
[17:29:45.728]                             invokeRestart(restart)
[17:29:45.728]                             muffled <- TRUE
[17:29:45.728]                             break
[17:29:45.728]                           }
[17:29:45.728]                         }
[17:29:45.728]                       }
[17:29:45.728]                       invisible(muffled)
[17:29:45.728]                     }
[17:29:45.728]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.728]                   }
[17:29:45.728]                 }
[17:29:45.728]             }
[17:29:45.728]         }))
[17:29:45.728]     }, error = function(ex) {
[17:29:45.728]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:45.728]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.728]                 ...future.rng), started = ...future.startTime, 
[17:29:45.728]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:45.728]             version = "1.8"), class = "FutureResult")
[17:29:45.728]     }, finally = {
[17:29:45.728]         if (!identical(...future.workdir, getwd())) 
[17:29:45.728]             setwd(...future.workdir)
[17:29:45.728]         {
[17:29:45.728]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:45.728]                 ...future.oldOptions$nwarnings <- NULL
[17:29:45.728]             }
[17:29:45.728]             base::options(...future.oldOptions)
[17:29:45.728]             if (.Platform$OS.type == "windows") {
[17:29:45.728]                 old_names <- names(...future.oldEnvVars)
[17:29:45.728]                 envs <- base::Sys.getenv()
[17:29:45.728]                 names <- names(envs)
[17:29:45.728]                 common <- intersect(names, old_names)
[17:29:45.728]                 added <- setdiff(names, old_names)
[17:29:45.728]                 removed <- setdiff(old_names, names)
[17:29:45.728]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:45.728]                   envs[common]]
[17:29:45.728]                 NAMES <- toupper(changed)
[17:29:45.728]                 args <- list()
[17:29:45.728]                 for (kk in seq_along(NAMES)) {
[17:29:45.728]                   name <- changed[[kk]]
[17:29:45.728]                   NAME <- NAMES[[kk]]
[17:29:45.728]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.728]                     next
[17:29:45.728]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.728]                 }
[17:29:45.728]                 NAMES <- toupper(added)
[17:29:45.728]                 for (kk in seq_along(NAMES)) {
[17:29:45.728]                   name <- added[[kk]]
[17:29:45.728]                   NAME <- NAMES[[kk]]
[17:29:45.728]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.728]                     next
[17:29:45.728]                   args[[name]] <- ""
[17:29:45.728]                 }
[17:29:45.728]                 NAMES <- toupper(removed)
[17:29:45.728]                 for (kk in seq_along(NAMES)) {
[17:29:45.728]                   name <- removed[[kk]]
[17:29:45.728]                   NAME <- NAMES[[kk]]
[17:29:45.728]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.728]                     next
[17:29:45.728]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.728]                 }
[17:29:45.728]                 if (length(args) > 0) 
[17:29:45.728]                   base::do.call(base::Sys.setenv, args = args)
[17:29:45.728]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:45.728]             }
[17:29:45.728]             else {
[17:29:45.728]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:45.728]             }
[17:29:45.728]             {
[17:29:45.728]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:45.728]                   0L) {
[17:29:45.728]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:45.728]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:45.728]                   base::options(opts)
[17:29:45.728]                 }
[17:29:45.728]                 {
[17:29:45.728]                   {
[17:29:45.728]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:45.728]                     NULL
[17:29:45.728]                   }
[17:29:45.728]                   options(future.plan = NULL)
[17:29:45.728]                   if (is.na(NA_character_)) 
[17:29:45.728]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.728]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:45.728]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:45.728]                     .init = FALSE)
[17:29:45.728]                 }
[17:29:45.728]             }
[17:29:45.728]         }
[17:29:45.728]     })
[17:29:45.728]     if (TRUE) {
[17:29:45.728]         base::sink(type = "output", split = FALSE)
[17:29:45.728]         if (TRUE) {
[17:29:45.728]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:45.728]         }
[17:29:45.728]         else {
[17:29:45.728]             ...future.result["stdout"] <- base::list(NULL)
[17:29:45.728]         }
[17:29:45.728]         base::close(...future.stdout)
[17:29:45.728]         ...future.stdout <- NULL
[17:29:45.728]     }
[17:29:45.728]     ...future.result$conditions <- ...future.conditions
[17:29:45.728]     ...future.result$finished <- base::Sys.time()
[17:29:45.728]     ...future.result
[17:29:45.728] }
[17:29:45.737] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:45.738] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:45.738] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:45.739] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:45.739] MultisessionFuture started
[17:29:45.740] - Launch lazy future ... done
[17:29:45.740] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_3-151414'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001addaa98c70
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:29:45.763] receiveMessageFromWorker() for ClusterFuture ...
[17:29:45.763] - Validating connection of MultisessionFuture
[17:29:45.764] - received message: FutureResult
[17:29:45.764] - Received FutureResult
[17:29:45.765] - Erased future from FutureRegistry
[17:29:45.765] result() for ClusterFuture ...
[17:29:45.765] - result already collected: FutureResult
[17:29:45.766] result() for ClusterFuture ... done
[17:29:45.766] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.767] getGlobalsAndPackages() ...
[17:29:45.767] Searching for globals...
[17:29:45.769] - globals found: [3] '{', 'sample', 'x'
[17:29:45.770] Searching for globals ... DONE
[17:29:45.770] Resolving globals: FALSE
[17:29:45.771] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:45.772] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:45.772] - globals: [1] 'x'
[17:29:45.772] 
[17:29:45.773] getGlobalsAndPackages() ... DONE
[17:29:45.773] run() for 'Future' ...
[17:29:45.774] - state: 'created'
[17:29:45.774] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:45.798] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.798] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:45.799]   - Field: 'node'
[17:29:45.799]   - Field: 'label'
[17:29:45.799]   - Field: 'local'
[17:29:45.800]   - Field: 'owner'
[17:29:45.800]   - Field: 'envir'
[17:29:45.801]   - Field: 'workers'
[17:29:45.801]   - Field: 'packages'
[17:29:45.801]   - Field: 'gc'
[17:29:45.802]   - Field: 'conditions'
[17:29:45.802]   - Field: 'persistent'
[17:29:45.802]   - Field: 'expr'
[17:29:45.803]   - Field: 'uuid'
[17:29:45.803]   - Field: 'seed'
[17:29:45.803]   - Field: 'version'
[17:29:45.804]   - Field: 'result'
[17:29:45.804]   - Field: 'asynchronous'
[17:29:45.804]   - Field: 'calls'
[17:29:45.805]   - Field: 'globals'
[17:29:45.805]   - Field: 'stdout'
[17:29:45.805]   - Field: 'earlySignal'
[17:29:45.806]   - Field: 'lazy'
[17:29:45.806]   - Field: 'state'
[17:29:45.806] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:45.807] - Launch lazy future ...
[17:29:45.807] Packages needed by the future expression (n = 0): <none>
[17:29:45.808] Packages needed by future strategies (n = 0): <none>
[17:29:45.809] {
[17:29:45.809]     {
[17:29:45.809]         {
[17:29:45.809]             ...future.startTime <- base::Sys.time()
[17:29:45.809]             {
[17:29:45.809]                 {
[17:29:45.809]                   {
[17:29:45.809]                     {
[17:29:45.809]                       base::local({
[17:29:45.809]                         has_future <- base::requireNamespace("future", 
[17:29:45.809]                           quietly = TRUE)
[17:29:45.809]                         if (has_future) {
[17:29:45.809]                           ns <- base::getNamespace("future")
[17:29:45.809]                           version <- ns[[".package"]][["version"]]
[17:29:45.809]                           if (is.null(version)) 
[17:29:45.809]                             version <- utils::packageVersion("future")
[17:29:45.809]                         }
[17:29:45.809]                         else {
[17:29:45.809]                           version <- NULL
[17:29:45.809]                         }
[17:29:45.809]                         if (!has_future || version < "1.8.0") {
[17:29:45.809]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:45.809]                             "", base::R.version$version.string), 
[17:29:45.809]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:45.809]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:45.809]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:45.809]                               "release", "version")], collapse = " "), 
[17:29:45.809]                             hostname = base::Sys.info()[["nodename"]])
[17:29:45.809]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:45.809]                             info)
[17:29:45.809]                           info <- base::paste(info, collapse = "; ")
[17:29:45.809]                           if (!has_future) {
[17:29:45.809]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:45.809]                               info)
[17:29:45.809]                           }
[17:29:45.809]                           else {
[17:29:45.809]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:45.809]                               info, version)
[17:29:45.809]                           }
[17:29:45.809]                           base::stop(msg)
[17:29:45.809]                         }
[17:29:45.809]                       })
[17:29:45.809]                     }
[17:29:45.809]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:45.809]                     base::options(mc.cores = 1L)
[17:29:45.809]                   }
[17:29:45.809]                   ...future.strategy.old <- future::plan("list")
[17:29:45.809]                   options(future.plan = NULL)
[17:29:45.809]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.809]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:45.809]                 }
[17:29:45.809]                 ...future.workdir <- getwd()
[17:29:45.809]             }
[17:29:45.809]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:45.809]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:45.809]         }
[17:29:45.809]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:45.809]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:45.809]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:45.809]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:45.809]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:45.809]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:45.809]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:45.809]             base::names(...future.oldOptions))
[17:29:45.809]     }
[17:29:45.809]     if (FALSE) {
[17:29:45.809]     }
[17:29:45.809]     else {
[17:29:45.809]         if (TRUE) {
[17:29:45.809]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:45.809]                 open = "w")
[17:29:45.809]         }
[17:29:45.809]         else {
[17:29:45.809]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:45.809]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:45.809]         }
[17:29:45.809]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:45.809]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:45.809]             base::sink(type = "output", split = FALSE)
[17:29:45.809]             base::close(...future.stdout)
[17:29:45.809]         }, add = TRUE)
[17:29:45.809]     }
[17:29:45.809]     ...future.frame <- base::sys.nframe()
[17:29:45.809]     ...future.conditions <- base::list()
[17:29:45.809]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:45.809]     if (FALSE) {
[17:29:45.809]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:45.809]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:45.809]     }
[17:29:45.809]     ...future.result <- base::tryCatch({
[17:29:45.809]         base::withCallingHandlers({
[17:29:45.809]             ...future.value <- base::withVisible(base::local({
[17:29:45.809]                 ...future.makeSendCondition <- base::local({
[17:29:45.809]                   sendCondition <- NULL
[17:29:45.809]                   function(frame = 1L) {
[17:29:45.809]                     if (is.function(sendCondition)) 
[17:29:45.809]                       return(sendCondition)
[17:29:45.809]                     ns <- getNamespace("parallel")
[17:29:45.809]                     if (exists("sendData", mode = "function", 
[17:29:45.809]                       envir = ns)) {
[17:29:45.809]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:45.809]                         envir = ns)
[17:29:45.809]                       envir <- sys.frame(frame)
[17:29:45.809]                       master <- NULL
[17:29:45.809]                       while (!identical(envir, .GlobalEnv) && 
[17:29:45.809]                         !identical(envir, emptyenv())) {
[17:29:45.809]                         if (exists("master", mode = "list", envir = envir, 
[17:29:45.809]                           inherits = FALSE)) {
[17:29:45.809]                           master <- get("master", mode = "list", 
[17:29:45.809]                             envir = envir, inherits = FALSE)
[17:29:45.809]                           if (inherits(master, c("SOCKnode", 
[17:29:45.809]                             "SOCK0node"))) {
[17:29:45.809]                             sendCondition <<- function(cond) {
[17:29:45.809]                               data <- list(type = "VALUE", value = cond, 
[17:29:45.809]                                 success = TRUE)
[17:29:45.809]                               parallel_sendData(master, data)
[17:29:45.809]                             }
[17:29:45.809]                             return(sendCondition)
[17:29:45.809]                           }
[17:29:45.809]                         }
[17:29:45.809]                         frame <- frame + 1L
[17:29:45.809]                         envir <- sys.frame(frame)
[17:29:45.809]                       }
[17:29:45.809]                     }
[17:29:45.809]                     sendCondition <<- function(cond) NULL
[17:29:45.809]                   }
[17:29:45.809]                 })
[17:29:45.809]                 withCallingHandlers({
[17:29:45.809]                   {
[17:29:45.809]                     sample(x, size = 1L)
[17:29:45.809]                   }
[17:29:45.809]                 }, immediateCondition = function(cond) {
[17:29:45.809]                   sendCondition <- ...future.makeSendCondition()
[17:29:45.809]                   sendCondition(cond)
[17:29:45.809]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.809]                   {
[17:29:45.809]                     inherits <- base::inherits
[17:29:45.809]                     invokeRestart <- base::invokeRestart
[17:29:45.809]                     is.null <- base::is.null
[17:29:45.809]                     muffled <- FALSE
[17:29:45.809]                     if (inherits(cond, "message")) {
[17:29:45.809]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:45.809]                       if (muffled) 
[17:29:45.809]                         invokeRestart("muffleMessage")
[17:29:45.809]                     }
[17:29:45.809]                     else if (inherits(cond, "warning")) {
[17:29:45.809]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:45.809]                       if (muffled) 
[17:29:45.809]                         invokeRestart("muffleWarning")
[17:29:45.809]                     }
[17:29:45.809]                     else if (inherits(cond, "condition")) {
[17:29:45.809]                       if (!is.null(pattern)) {
[17:29:45.809]                         computeRestarts <- base::computeRestarts
[17:29:45.809]                         grepl <- base::grepl
[17:29:45.809]                         restarts <- computeRestarts(cond)
[17:29:45.809]                         for (restart in restarts) {
[17:29:45.809]                           name <- restart$name
[17:29:45.809]                           if (is.null(name)) 
[17:29:45.809]                             next
[17:29:45.809]                           if (!grepl(pattern, name)) 
[17:29:45.809]                             next
[17:29:45.809]                           invokeRestart(restart)
[17:29:45.809]                           muffled <- TRUE
[17:29:45.809]                           break
[17:29:45.809]                         }
[17:29:45.809]                       }
[17:29:45.809]                     }
[17:29:45.809]                     invisible(muffled)
[17:29:45.809]                   }
[17:29:45.809]                   muffleCondition(cond)
[17:29:45.809]                 })
[17:29:45.809]             }))
[17:29:45.809]             future::FutureResult(value = ...future.value$value, 
[17:29:45.809]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.809]                   ...future.rng), globalenv = if (FALSE) 
[17:29:45.809]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:45.809]                     ...future.globalenv.names))
[17:29:45.809]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:45.809]         }, condition = base::local({
[17:29:45.809]             c <- base::c
[17:29:45.809]             inherits <- base::inherits
[17:29:45.809]             invokeRestart <- base::invokeRestart
[17:29:45.809]             length <- base::length
[17:29:45.809]             list <- base::list
[17:29:45.809]             seq.int <- base::seq.int
[17:29:45.809]             signalCondition <- base::signalCondition
[17:29:45.809]             sys.calls <- base::sys.calls
[17:29:45.809]             `[[` <- base::`[[`
[17:29:45.809]             `+` <- base::`+`
[17:29:45.809]             `<<-` <- base::`<<-`
[17:29:45.809]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:45.809]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:45.809]                   3L)]
[17:29:45.809]             }
[17:29:45.809]             function(cond) {
[17:29:45.809]                 is_error <- inherits(cond, "error")
[17:29:45.809]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:45.809]                   NULL)
[17:29:45.809]                 if (is_error) {
[17:29:45.809]                   sessionInformation <- function() {
[17:29:45.809]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:45.809]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:45.809]                       search = base::search(), system = base::Sys.info())
[17:29:45.809]                   }
[17:29:45.809]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.809]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:45.809]                     cond$call), session = sessionInformation(), 
[17:29:45.809]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:45.809]                   signalCondition(cond)
[17:29:45.809]                 }
[17:29:45.809]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:45.809]                 "immediateCondition"))) {
[17:29:45.809]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:45.809]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.809]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:45.809]                   if (TRUE && !signal) {
[17:29:45.809]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.809]                     {
[17:29:45.809]                       inherits <- base::inherits
[17:29:45.809]                       invokeRestart <- base::invokeRestart
[17:29:45.809]                       is.null <- base::is.null
[17:29:45.809]                       muffled <- FALSE
[17:29:45.809]                       if (inherits(cond, "message")) {
[17:29:45.809]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.809]                         if (muffled) 
[17:29:45.809]                           invokeRestart("muffleMessage")
[17:29:45.809]                       }
[17:29:45.809]                       else if (inherits(cond, "warning")) {
[17:29:45.809]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.809]                         if (muffled) 
[17:29:45.809]                           invokeRestart("muffleWarning")
[17:29:45.809]                       }
[17:29:45.809]                       else if (inherits(cond, "condition")) {
[17:29:45.809]                         if (!is.null(pattern)) {
[17:29:45.809]                           computeRestarts <- base::computeRestarts
[17:29:45.809]                           grepl <- base::grepl
[17:29:45.809]                           restarts <- computeRestarts(cond)
[17:29:45.809]                           for (restart in restarts) {
[17:29:45.809]                             name <- restart$name
[17:29:45.809]                             if (is.null(name)) 
[17:29:45.809]                               next
[17:29:45.809]                             if (!grepl(pattern, name)) 
[17:29:45.809]                               next
[17:29:45.809]                             invokeRestart(restart)
[17:29:45.809]                             muffled <- TRUE
[17:29:45.809]                             break
[17:29:45.809]                           }
[17:29:45.809]                         }
[17:29:45.809]                       }
[17:29:45.809]                       invisible(muffled)
[17:29:45.809]                     }
[17:29:45.809]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.809]                   }
[17:29:45.809]                 }
[17:29:45.809]                 else {
[17:29:45.809]                   if (TRUE) {
[17:29:45.809]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.809]                     {
[17:29:45.809]                       inherits <- base::inherits
[17:29:45.809]                       invokeRestart <- base::invokeRestart
[17:29:45.809]                       is.null <- base::is.null
[17:29:45.809]                       muffled <- FALSE
[17:29:45.809]                       if (inherits(cond, "message")) {
[17:29:45.809]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.809]                         if (muffled) 
[17:29:45.809]                           invokeRestart("muffleMessage")
[17:29:45.809]                       }
[17:29:45.809]                       else if (inherits(cond, "warning")) {
[17:29:45.809]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.809]                         if (muffled) 
[17:29:45.809]                           invokeRestart("muffleWarning")
[17:29:45.809]                       }
[17:29:45.809]                       else if (inherits(cond, "condition")) {
[17:29:45.809]                         if (!is.null(pattern)) {
[17:29:45.809]                           computeRestarts <- base::computeRestarts
[17:29:45.809]                           grepl <- base::grepl
[17:29:45.809]                           restarts <- computeRestarts(cond)
[17:29:45.809]                           for (restart in restarts) {
[17:29:45.809]                             name <- restart$name
[17:29:45.809]                             if (is.null(name)) 
[17:29:45.809]                               next
[17:29:45.809]                             if (!grepl(pattern, name)) 
[17:29:45.809]                               next
[17:29:45.809]                             invokeRestart(restart)
[17:29:45.809]                             muffled <- TRUE
[17:29:45.809]                             break
[17:29:45.809]                           }
[17:29:45.809]                         }
[17:29:45.809]                       }
[17:29:45.809]                       invisible(muffled)
[17:29:45.809]                     }
[17:29:45.809]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.809]                   }
[17:29:45.809]                 }
[17:29:45.809]             }
[17:29:45.809]         }))
[17:29:45.809]     }, error = function(ex) {
[17:29:45.809]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:45.809]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.809]                 ...future.rng), started = ...future.startTime, 
[17:29:45.809]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:45.809]             version = "1.8"), class = "FutureResult")
[17:29:45.809]     }, finally = {
[17:29:45.809]         if (!identical(...future.workdir, getwd())) 
[17:29:45.809]             setwd(...future.workdir)
[17:29:45.809]         {
[17:29:45.809]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:45.809]                 ...future.oldOptions$nwarnings <- NULL
[17:29:45.809]             }
[17:29:45.809]             base::options(...future.oldOptions)
[17:29:45.809]             if (.Platform$OS.type == "windows") {
[17:29:45.809]                 old_names <- names(...future.oldEnvVars)
[17:29:45.809]                 envs <- base::Sys.getenv()
[17:29:45.809]                 names <- names(envs)
[17:29:45.809]                 common <- intersect(names, old_names)
[17:29:45.809]                 added <- setdiff(names, old_names)
[17:29:45.809]                 removed <- setdiff(old_names, names)
[17:29:45.809]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:45.809]                   envs[common]]
[17:29:45.809]                 NAMES <- toupper(changed)
[17:29:45.809]                 args <- list()
[17:29:45.809]                 for (kk in seq_along(NAMES)) {
[17:29:45.809]                   name <- changed[[kk]]
[17:29:45.809]                   NAME <- NAMES[[kk]]
[17:29:45.809]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.809]                     next
[17:29:45.809]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.809]                 }
[17:29:45.809]                 NAMES <- toupper(added)
[17:29:45.809]                 for (kk in seq_along(NAMES)) {
[17:29:45.809]                   name <- added[[kk]]
[17:29:45.809]                   NAME <- NAMES[[kk]]
[17:29:45.809]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.809]                     next
[17:29:45.809]                   args[[name]] <- ""
[17:29:45.809]                 }
[17:29:45.809]                 NAMES <- toupper(removed)
[17:29:45.809]                 for (kk in seq_along(NAMES)) {
[17:29:45.809]                   name <- removed[[kk]]
[17:29:45.809]                   NAME <- NAMES[[kk]]
[17:29:45.809]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.809]                     next
[17:29:45.809]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.809]                 }
[17:29:45.809]                 if (length(args) > 0) 
[17:29:45.809]                   base::do.call(base::Sys.setenv, args = args)
[17:29:45.809]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:45.809]             }
[17:29:45.809]             else {
[17:29:45.809]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:45.809]             }
[17:29:45.809]             {
[17:29:45.809]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:45.809]                   0L) {
[17:29:45.809]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:45.809]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:45.809]                   base::options(opts)
[17:29:45.809]                 }
[17:29:45.809]                 {
[17:29:45.809]                   {
[17:29:45.809]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:45.809]                     NULL
[17:29:45.809]                   }
[17:29:45.809]                   options(future.plan = NULL)
[17:29:45.809]                   if (is.na(NA_character_)) 
[17:29:45.809]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.809]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:45.809]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:45.809]                     .init = FALSE)
[17:29:45.809]                 }
[17:29:45.809]             }
[17:29:45.809]         }
[17:29:45.809]     })
[17:29:45.809]     if (TRUE) {
[17:29:45.809]         base::sink(type = "output", split = FALSE)
[17:29:45.809]         if (TRUE) {
[17:29:45.809]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:45.809]         }
[17:29:45.809]         else {
[17:29:45.809]             ...future.result["stdout"] <- base::list(NULL)
[17:29:45.809]         }
[17:29:45.809]         base::close(...future.stdout)
[17:29:45.809]         ...future.stdout <- NULL
[17:29:45.809]     }
[17:29:45.809]     ...future.result$conditions <- ...future.conditions
[17:29:45.809]     ...future.result$finished <- base::Sys.time()
[17:29:45.809]     ...future.result
[17:29:45.809] }
[17:29:45.818] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:45.819] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:45.820] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:45.820] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:45.821] MultisessionFuture started
[17:29:45.821] - Launch lazy future ... done
[17:29:45.821] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_4-744727'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001addaa98c70
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:29:45.845] receiveMessageFromWorker() for ClusterFuture ...
[17:29:45.845] - Validating connection of MultisessionFuture
[17:29:45.845] - received message: FutureResult
[17:29:45.846] - Received FutureResult
[17:29:45.846] - Erased future from FutureRegistry
[17:29:45.846] result() for ClusterFuture ...
[17:29:45.846] - result already collected: FutureResult
[17:29:45.846] result() for ClusterFuture ... done
[17:29:45.847] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.847] resolve() on list ...
[17:29:45.847]  recursive: 0
[17:29:45.848]  length: 4
[17:29:45.848] 
[17:29:45.849] Future #1
[17:29:45.849] result() for ClusterFuture ...
[17:29:45.849] - result already collected: FutureResult
[17:29:45.850] result() for ClusterFuture ... done
[17:29:45.850] result() for ClusterFuture ...
[17:29:45.850] - result already collected: FutureResult
[17:29:45.850] result() for ClusterFuture ... done
[17:29:45.851] signalConditionsASAP(MultisessionFuture, pos=1) ...
[17:29:45.852] - nx: 4
[17:29:45.852] - relay: TRUE
[17:29:45.856] - stdout: TRUE
[17:29:45.856] - signal: TRUE
[17:29:45.856] - resignal: FALSE
[17:29:45.857] - force: TRUE
[17:29:45.857] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:45.857] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:45.857]  - until=1
[17:29:45.857]  - relaying element #1
[17:29:45.858] result() for ClusterFuture ...
[17:29:45.858] - result already collected: FutureResult
[17:29:45.858] result() for ClusterFuture ... done
[17:29:45.858] result() for ClusterFuture ...
[17:29:45.859] - result already collected: FutureResult
[17:29:45.859] result() for ClusterFuture ... done
[17:29:45.859] signalConditions() ...
[17:29:45.859]  - include = 'immediateCondition'
[17:29:45.859]  - exclude = 
[17:29:45.860]  - resignal = FALSE
[17:29:45.860]  - Number of conditions: 1
[17:29:45.860] signalConditions() ... done
[17:29:45.861] result() for ClusterFuture ...
[17:29:45.861] - result already collected: FutureResult
[17:29:45.861] result() for ClusterFuture ... done
[17:29:45.861] signalConditions() ...
[17:29:45.861]  - include = 'immediateCondition'
[17:29:45.862]  - exclude = 
[17:29:45.862]  - resignal = FALSE
[17:29:45.862]  - Number of conditions: 1
[17:29:45.862] signalConditions() ... done
[17:29:45.863] result() for ClusterFuture ...
[17:29:45.863] - result already collected: FutureResult
[17:29:45.863] result() for ClusterFuture ... done
[17:29:45.863] signalConditions() ...
[17:29:45.863]  - include = 'condition'
[17:29:45.864]  - exclude = 'immediateCondition'
[17:29:45.864]  - resignal = TRUE
[17:29:45.864]  - Number of conditions: 1
[17:29:45.864]  - Condition #1: 'RngFutureWarning', 'FutureWarning', 'warning', 'RngFutureCondition', 'FutureCondition', 'condition'
[17:29:45.865] signalConditions() ... done
[17:29:45.865] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:45.865] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:45.865] signalConditionsASAP(MultisessionFuture, pos=1) ... done
<RngFutureWarning: UNRELIABLE VALUE: Future ('fsample_1-757701') 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: bb1bbc43-ab48-1034-78e2-87e2a6c54f88


DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
MultisessionFuture:
Label: 'fsample_1-757701'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001addaa98c70
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Conditions captured: [n=1] 'RngFutureWarning'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'

DEBUG: END TROUBLESHOOTING HELP
[17:29:45.867] getGlobalsAndPackages() ...
[17:29:45.867] Searching for globals...
[17:29:45.870] - globals found: [3] '{', 'sample', 'x'
[17:29:45.870] Searching for globals ... DONE
[17:29:45.870] Resolving globals: FALSE
[17:29:45.871] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:45.872] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:45.872] - globals: [1] 'x'
[17:29:45.872] 
[17:29:45.873] getGlobalsAndPackages() ... DONE
[17:29:45.873] run() for 'Future' ...
[17:29:45.874] - state: 'created'
[17:29:45.874] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:45.893] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.894] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:45.894]   - Field: 'node'
[17:29:45.894]   - Field: 'label'
[17:29:45.895]   - Field: 'local'
[17:29:45.895]   - Field: 'owner'
[17:29:45.895]   - Field: 'envir'
[17:29:45.895]   - Field: 'workers'
[17:29:45.895]   - Field: 'packages'
[17:29:45.895]   - Field: 'gc'
[17:29:45.896]   - Field: 'conditions'
[17:29:45.896]   - Field: 'persistent'
[17:29:45.896]   - Field: 'expr'
[17:29:45.896]   - Field: 'uuid'
[17:29:45.896]   - Field: 'seed'
[17:29:45.896]   - Field: 'version'
[17:29:45.897]   - Field: 'result'
[17:29:45.897]   - Field: 'asynchronous'
[17:29:45.897]   - Field: 'calls'
[17:29:45.897]   - Field: 'globals'
[17:29:45.897]   - Field: 'stdout'
[17:29:45.897]   - Field: 'earlySignal'
[17:29:45.898]   - Field: 'lazy'
[17:29:45.898]   - Field: 'state'
[17:29:45.898] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:45.898] - Launch lazy future ...
[17:29:45.898] Packages needed by the future expression (n = 0): <none>
[17:29:45.899] Packages needed by future strategies (n = 0): <none>
[17:29:45.899] {
[17:29:45.899]     {
[17:29:45.899]         {
[17:29:45.899]             ...future.startTime <- base::Sys.time()
[17:29:45.899]             {
[17:29:45.899]                 {
[17:29:45.899]                   {
[17:29:45.899]                     {
[17:29:45.899]                       base::local({
[17:29:45.899]                         has_future <- base::requireNamespace("future", 
[17:29:45.899]                           quietly = TRUE)
[17:29:45.899]                         if (has_future) {
[17:29:45.899]                           ns <- base::getNamespace("future")
[17:29:45.899]                           version <- ns[[".package"]][["version"]]
[17:29:45.899]                           if (is.null(version)) 
[17:29:45.899]                             version <- utils::packageVersion("future")
[17:29:45.899]                         }
[17:29:45.899]                         else {
[17:29:45.899]                           version <- NULL
[17:29:45.899]                         }
[17:29:45.899]                         if (!has_future || version < "1.8.0") {
[17:29:45.899]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:45.899]                             "", base::R.version$version.string), 
[17:29:45.899]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:45.899]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:45.899]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:45.899]                               "release", "version")], collapse = " "), 
[17:29:45.899]                             hostname = base::Sys.info()[["nodename"]])
[17:29:45.899]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:45.899]                             info)
[17:29:45.899]                           info <- base::paste(info, collapse = "; ")
[17:29:45.899]                           if (!has_future) {
[17:29:45.899]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:45.899]                               info)
[17:29:45.899]                           }
[17:29:45.899]                           else {
[17:29:45.899]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:45.899]                               info, version)
[17:29:45.899]                           }
[17:29:45.899]                           base::stop(msg)
[17:29:45.899]                         }
[17:29:45.899]                       })
[17:29:45.899]                     }
[17:29:45.899]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:45.899]                     base::options(mc.cores = 1L)
[17:29:45.899]                   }
[17:29:45.899]                   ...future.strategy.old <- future::plan("list")
[17:29:45.899]                   options(future.plan = NULL)
[17:29:45.899]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.899]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:45.899]                 }
[17:29:45.899]                 ...future.workdir <- getwd()
[17:29:45.899]             }
[17:29:45.899]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:45.899]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:45.899]         }
[17:29:45.899]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:45.899]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:45.899]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:45.899]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:45.899]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:45.899]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:45.899]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:45.899]             base::names(...future.oldOptions))
[17:29:45.899]     }
[17:29:45.899]     if (FALSE) {
[17:29:45.899]     }
[17:29:45.899]     else {
[17:29:45.899]         if (TRUE) {
[17:29:45.899]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:45.899]                 open = "w")
[17:29:45.899]         }
[17:29:45.899]         else {
[17:29:45.899]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:45.899]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:45.899]         }
[17:29:45.899]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:45.899]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:45.899]             base::sink(type = "output", split = FALSE)
[17:29:45.899]             base::close(...future.stdout)
[17:29:45.899]         }, add = TRUE)
[17:29:45.899]     }
[17:29:45.899]     ...future.frame <- base::sys.nframe()
[17:29:45.899]     ...future.conditions <- base::list()
[17:29:45.899]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:45.899]     if (FALSE) {
[17:29:45.899]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:45.899]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:45.899]     }
[17:29:45.899]     ...future.result <- base::tryCatch({
[17:29:45.899]         base::withCallingHandlers({
[17:29:45.899]             ...future.value <- base::withVisible(base::local({
[17:29:45.899]                 ...future.makeSendCondition <- base::local({
[17:29:45.899]                   sendCondition <- NULL
[17:29:45.899]                   function(frame = 1L) {
[17:29:45.899]                     if (is.function(sendCondition)) 
[17:29:45.899]                       return(sendCondition)
[17:29:45.899]                     ns <- getNamespace("parallel")
[17:29:45.899]                     if (exists("sendData", mode = "function", 
[17:29:45.899]                       envir = ns)) {
[17:29:45.899]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:45.899]                         envir = ns)
[17:29:45.899]                       envir <- sys.frame(frame)
[17:29:45.899]                       master <- NULL
[17:29:45.899]                       while (!identical(envir, .GlobalEnv) && 
[17:29:45.899]                         !identical(envir, emptyenv())) {
[17:29:45.899]                         if (exists("master", mode = "list", envir = envir, 
[17:29:45.899]                           inherits = FALSE)) {
[17:29:45.899]                           master <- get("master", mode = "list", 
[17:29:45.899]                             envir = envir, inherits = FALSE)
[17:29:45.899]                           if (inherits(master, c("SOCKnode", 
[17:29:45.899]                             "SOCK0node"))) {
[17:29:45.899]                             sendCondition <<- function(cond) {
[17:29:45.899]                               data <- list(type = "VALUE", value = cond, 
[17:29:45.899]                                 success = TRUE)
[17:29:45.899]                               parallel_sendData(master, data)
[17:29:45.899]                             }
[17:29:45.899]                             return(sendCondition)
[17:29:45.899]                           }
[17:29:45.899]                         }
[17:29:45.899]                         frame <- frame + 1L
[17:29:45.899]                         envir <- sys.frame(frame)
[17:29:45.899]                       }
[17:29:45.899]                     }
[17:29:45.899]                     sendCondition <<- function(cond) NULL
[17:29:45.899]                   }
[17:29:45.899]                 })
[17:29:45.899]                 withCallingHandlers({
[17:29:45.899]                   {
[17:29:45.899]                     sample(x, size = 1L)
[17:29:45.899]                   }
[17:29:45.899]                 }, immediateCondition = function(cond) {
[17:29:45.899]                   sendCondition <- ...future.makeSendCondition()
[17:29:45.899]                   sendCondition(cond)
[17:29:45.899]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.899]                   {
[17:29:45.899]                     inherits <- base::inherits
[17:29:45.899]                     invokeRestart <- base::invokeRestart
[17:29:45.899]                     is.null <- base::is.null
[17:29:45.899]                     muffled <- FALSE
[17:29:45.899]                     if (inherits(cond, "message")) {
[17:29:45.899]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:45.899]                       if (muffled) 
[17:29:45.899]                         invokeRestart("muffleMessage")
[17:29:45.899]                     }
[17:29:45.899]                     else if (inherits(cond, "warning")) {
[17:29:45.899]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:45.899]                       if (muffled) 
[17:29:45.899]                         invokeRestart("muffleWarning")
[17:29:45.899]                     }
[17:29:45.899]                     else if (inherits(cond, "condition")) {
[17:29:45.899]                       if (!is.null(pattern)) {
[17:29:45.899]                         computeRestarts <- base::computeRestarts
[17:29:45.899]                         grepl <- base::grepl
[17:29:45.899]                         restarts <- computeRestarts(cond)
[17:29:45.899]                         for (restart in restarts) {
[17:29:45.899]                           name <- restart$name
[17:29:45.899]                           if (is.null(name)) 
[17:29:45.899]                             next
[17:29:45.899]                           if (!grepl(pattern, name)) 
[17:29:45.899]                             next
[17:29:45.899]                           invokeRestart(restart)
[17:29:45.899]                           muffled <- TRUE
[17:29:45.899]                           break
[17:29:45.899]                         }
[17:29:45.899]                       }
[17:29:45.899]                     }
[17:29:45.899]                     invisible(muffled)
[17:29:45.899]                   }
[17:29:45.899]                   muffleCondition(cond)
[17:29:45.899]                 })
[17:29:45.899]             }))
[17:29:45.899]             future::FutureResult(value = ...future.value$value, 
[17:29:45.899]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.899]                   ...future.rng), globalenv = if (FALSE) 
[17:29:45.899]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:45.899]                     ...future.globalenv.names))
[17:29:45.899]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:45.899]         }, condition = base::local({
[17:29:45.899]             c <- base::c
[17:29:45.899]             inherits <- base::inherits
[17:29:45.899]             invokeRestart <- base::invokeRestart
[17:29:45.899]             length <- base::length
[17:29:45.899]             list <- base::list
[17:29:45.899]             seq.int <- base::seq.int
[17:29:45.899]             signalCondition <- base::signalCondition
[17:29:45.899]             sys.calls <- base::sys.calls
[17:29:45.899]             `[[` <- base::`[[`
[17:29:45.899]             `+` <- base::`+`
[17:29:45.899]             `<<-` <- base::`<<-`
[17:29:45.899]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:45.899]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:45.899]                   3L)]
[17:29:45.899]             }
[17:29:45.899]             function(cond) {
[17:29:45.899]                 is_error <- inherits(cond, "error")
[17:29:45.899]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:45.899]                   NULL)
[17:29:45.899]                 if (is_error) {
[17:29:45.899]                   sessionInformation <- function() {
[17:29:45.899]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:45.899]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:45.899]                       search = base::search(), system = base::Sys.info())
[17:29:45.899]                   }
[17:29:45.899]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.899]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:45.899]                     cond$call), session = sessionInformation(), 
[17:29:45.899]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:45.899]                   signalCondition(cond)
[17:29:45.899]                 }
[17:29:45.899]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:45.899]                 "immediateCondition"))) {
[17:29:45.899]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:45.899]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.899]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:45.899]                   if (TRUE && !signal) {
[17:29:45.899]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.899]                     {
[17:29:45.899]                       inherits <- base::inherits
[17:29:45.899]                       invokeRestart <- base::invokeRestart
[17:29:45.899]                       is.null <- base::is.null
[17:29:45.899]                       muffled <- FALSE
[17:29:45.899]                       if (inherits(cond, "message")) {
[17:29:45.899]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.899]                         if (muffled) 
[17:29:45.899]                           invokeRestart("muffleMessage")
[17:29:45.899]                       }
[17:29:45.899]                       else if (inherits(cond, "warning")) {
[17:29:45.899]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.899]                         if (muffled) 
[17:29:45.899]                           invokeRestart("muffleWarning")
[17:29:45.899]                       }
[17:29:45.899]                       else if (inherits(cond, "condition")) {
[17:29:45.899]                         if (!is.null(pattern)) {
[17:29:45.899]                           computeRestarts <- base::computeRestarts
[17:29:45.899]                           grepl <- base::grepl
[17:29:45.899]                           restarts <- computeRestarts(cond)
[17:29:45.899]                           for (restart in restarts) {
[17:29:45.899]                             name <- restart$name
[17:29:45.899]                             if (is.null(name)) 
[17:29:45.899]                               next
[17:29:45.899]                             if (!grepl(pattern, name)) 
[17:29:45.899]                               next
[17:29:45.899]                             invokeRestart(restart)
[17:29:45.899]                             muffled <- TRUE
[17:29:45.899]                             break
[17:29:45.899]                           }
[17:29:45.899]                         }
[17:29:45.899]                       }
[17:29:45.899]                       invisible(muffled)
[17:29:45.899]                     }
[17:29:45.899]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.899]                   }
[17:29:45.899]                 }
[17:29:45.899]                 else {
[17:29:45.899]                   if (TRUE) {
[17:29:45.899]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.899]                     {
[17:29:45.899]                       inherits <- base::inherits
[17:29:45.899]                       invokeRestart <- base::invokeRestart
[17:29:45.899]                       is.null <- base::is.null
[17:29:45.899]                       muffled <- FALSE
[17:29:45.899]                       if (inherits(cond, "message")) {
[17:29:45.899]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.899]                         if (muffled) 
[17:29:45.899]                           invokeRestart("muffleMessage")
[17:29:45.899]                       }
[17:29:45.899]                       else if (inherits(cond, "warning")) {
[17:29:45.899]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.899]                         if (muffled) 
[17:29:45.899]                           invokeRestart("muffleWarning")
[17:29:45.899]                       }
[17:29:45.899]                       else if (inherits(cond, "condition")) {
[17:29:45.899]                         if (!is.null(pattern)) {
[17:29:45.899]                           computeRestarts <- base::computeRestarts
[17:29:45.899]                           grepl <- base::grepl
[17:29:45.899]                           restarts <- computeRestarts(cond)
[17:29:45.899]                           for (restart in restarts) {
[17:29:45.899]                             name <- restart$name
[17:29:45.899]                             if (is.null(name)) 
[17:29:45.899]                               next
[17:29:45.899]                             if (!grepl(pattern, name)) 
[17:29:45.899]                               next
[17:29:45.899]                             invokeRestart(restart)
[17:29:45.899]                             muffled <- TRUE
[17:29:45.899]                             break
[17:29:45.899]                           }
[17:29:45.899]                         }
[17:29:45.899]                       }
[17:29:45.899]                       invisible(muffled)
[17:29:45.899]                     }
[17:29:45.899]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.899]                   }
[17:29:45.899]                 }
[17:29:45.899]             }
[17:29:45.899]         }))
[17:29:45.899]     }, error = function(ex) {
[17:29:45.899]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:45.899]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.899]                 ...future.rng), started = ...future.startTime, 
[17:29:45.899]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:45.899]             version = "1.8"), class = "FutureResult")
[17:29:45.899]     }, finally = {
[17:29:45.899]         if (!identical(...future.workdir, getwd())) 
[17:29:45.899]             setwd(...future.workdir)
[17:29:45.899]         {
[17:29:45.899]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:45.899]                 ...future.oldOptions$nwarnings <- NULL
[17:29:45.899]             }
[17:29:45.899]             base::options(...future.oldOptions)
[17:29:45.899]             if (.Platform$OS.type == "windows") {
[17:29:45.899]                 old_names <- names(...future.oldEnvVars)
[17:29:45.899]                 envs <- base::Sys.getenv()
[17:29:45.899]                 names <- names(envs)
[17:29:45.899]                 common <- intersect(names, old_names)
[17:29:45.899]                 added <- setdiff(names, old_names)
[17:29:45.899]                 removed <- setdiff(old_names, names)
[17:29:45.899]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:45.899]                   envs[common]]
[17:29:45.899]                 NAMES <- toupper(changed)
[17:29:45.899]                 args <- list()
[17:29:45.899]                 for (kk in seq_along(NAMES)) {
[17:29:45.899]                   name <- changed[[kk]]
[17:29:45.899]                   NAME <- NAMES[[kk]]
[17:29:45.899]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.899]                     next
[17:29:45.899]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.899]                 }
[17:29:45.899]                 NAMES <- toupper(added)
[17:29:45.899]                 for (kk in seq_along(NAMES)) {
[17:29:45.899]                   name <- added[[kk]]
[17:29:45.899]                   NAME <- NAMES[[kk]]
[17:29:45.899]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.899]                     next
[17:29:45.899]                   args[[name]] <- ""
[17:29:45.899]                 }
[17:29:45.899]                 NAMES <- toupper(removed)
[17:29:45.899]                 for (kk in seq_along(NAMES)) {
[17:29:45.899]                   name <- removed[[kk]]
[17:29:45.899]                   NAME <- NAMES[[kk]]
[17:29:45.899]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.899]                     next
[17:29:45.899]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.899]                 }
[17:29:45.899]                 if (length(args) > 0) 
[17:29:45.899]                   base::do.call(base::Sys.setenv, args = args)
[17:29:45.899]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:45.899]             }
[17:29:45.899]             else {
[17:29:45.899]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:45.899]             }
[17:29:45.899]             {
[17:29:45.899]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:45.899]                   0L) {
[17:29:45.899]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:45.899]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:45.899]                   base::options(opts)
[17:29:45.899]                 }
[17:29:45.899]                 {
[17:29:45.899]                   {
[17:29:45.899]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:45.899]                     NULL
[17:29:45.899]                   }
[17:29:45.899]                   options(future.plan = NULL)
[17:29:45.899]                   if (is.na(NA_character_)) 
[17:29:45.899]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.899]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:45.899]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:45.899]                     .init = FALSE)
[17:29:45.899]                 }
[17:29:45.899]             }
[17:29:45.899]         }
[17:29:45.899]     })
[17:29:45.899]     if (TRUE) {
[17:29:45.899]         base::sink(type = "output", split = FALSE)
[17:29:45.899]         if (TRUE) {
[17:29:45.899]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:45.899]         }
[17:29:45.899]         else {
[17:29:45.899]             ...future.result["stdout"] <- base::list(NULL)
[17:29:45.899]         }
[17:29:45.899]         base::close(...future.stdout)
[17:29:45.899]         ...future.stdout <- NULL
[17:29:45.899]     }
[17:29:45.899]     ...future.result$conditions <- ...future.conditions
[17:29:45.899]     ...future.result$finished <- base::Sys.time()
[17:29:45.899]     ...future.result
[17:29:45.899] }
[17:29:45.904] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:45.904] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:45.905] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:45.905] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:45.906] MultisessionFuture started
[17:29:45.906] - Launch lazy future ... done
[17:29:45.906] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_1-637072'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001addb4a7098
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:29:45.923] receiveMessageFromWorker() for ClusterFuture ...
[17:29:45.924] - Validating connection of MultisessionFuture
[17:29:45.924] - received message: FutureResult
[17:29:45.924] - Received FutureResult
[17:29:45.925] - Erased future from FutureRegistry
[17:29:45.925] result() for ClusterFuture ...
[17:29:45.925] - result already collected: FutureResult
[17:29:45.926] result() for ClusterFuture ... done
[17:29:45.926] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.926] getGlobalsAndPackages() ...
[17:29:45.927] Searching for globals...
[17:29:45.929] - globals found: [3] '{', 'sample', 'x'
[17:29:45.929] Searching for globals ... DONE
[17:29:45.929] Resolving globals: FALSE
[17:29:45.930] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:45.931] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:45.931] - globals: [1] 'x'
[17:29:45.931] 
[17:29:45.931] getGlobalsAndPackages() ... DONE
[17:29:45.932] run() for 'Future' ...
[17:29:45.932] - state: 'created'
[17:29:45.933] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:45.951] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:45.951] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:45.951]   - Field: 'node'
[17:29:45.952]   - Field: 'label'
[17:29:45.952]   - Field: 'local'
[17:29:45.952]   - Field: 'owner'
[17:29:45.953]   - Field: 'envir'
[17:29:45.953]   - Field: 'workers'
[17:29:45.953]   - Field: 'packages'
[17:29:45.953]   - Field: 'gc'
[17:29:45.954]   - Field: 'conditions'
[17:29:45.954]   - Field: 'persistent'
[17:29:45.954]   - Field: 'expr'
[17:29:45.955]   - Field: 'uuid'
[17:29:45.955]   - Field: 'seed'
[17:29:45.955]   - Field: 'version'
[17:29:45.955]   - Field: 'result'
[17:29:45.956]   - Field: 'asynchronous'
[17:29:45.956]   - Field: 'calls'
[17:29:45.956]   - Field: 'globals'
[17:29:45.957]   - Field: 'stdout'
[17:29:45.957]   - Field: 'earlySignal'
[17:29:45.957]   - Field: 'lazy'
[17:29:45.958]   - Field: 'state'
[17:29:45.958] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:45.958] - Launch lazy future ...
[17:29:45.959] Packages needed by the future expression (n = 0): <none>
[17:29:45.959] Packages needed by future strategies (n = 0): <none>
[17:29:45.960] {
[17:29:45.960]     {
[17:29:45.960]         {
[17:29:45.960]             ...future.startTime <- base::Sys.time()
[17:29:45.960]             {
[17:29:45.960]                 {
[17:29:45.960]                   {
[17:29:45.960]                     {
[17:29:45.960]                       base::local({
[17:29:45.960]                         has_future <- base::requireNamespace("future", 
[17:29:45.960]                           quietly = TRUE)
[17:29:45.960]                         if (has_future) {
[17:29:45.960]                           ns <- base::getNamespace("future")
[17:29:45.960]                           version <- ns[[".package"]][["version"]]
[17:29:45.960]                           if (is.null(version)) 
[17:29:45.960]                             version <- utils::packageVersion("future")
[17:29:45.960]                         }
[17:29:45.960]                         else {
[17:29:45.960]                           version <- NULL
[17:29:45.960]                         }
[17:29:45.960]                         if (!has_future || version < "1.8.0") {
[17:29:45.960]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:45.960]                             "", base::R.version$version.string), 
[17:29:45.960]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:45.960]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:45.960]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:45.960]                               "release", "version")], collapse = " "), 
[17:29:45.960]                             hostname = base::Sys.info()[["nodename"]])
[17:29:45.960]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:45.960]                             info)
[17:29:45.960]                           info <- base::paste(info, collapse = "; ")
[17:29:45.960]                           if (!has_future) {
[17:29:45.960]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:45.960]                               info)
[17:29:45.960]                           }
[17:29:45.960]                           else {
[17:29:45.960]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:45.960]                               info, version)
[17:29:45.960]                           }
[17:29:45.960]                           base::stop(msg)
[17:29:45.960]                         }
[17:29:45.960]                       })
[17:29:45.960]                     }
[17:29:45.960]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:45.960]                     base::options(mc.cores = 1L)
[17:29:45.960]                   }
[17:29:45.960]                   ...future.strategy.old <- future::plan("list")
[17:29:45.960]                   options(future.plan = NULL)
[17:29:45.960]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.960]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:45.960]                 }
[17:29:45.960]                 ...future.workdir <- getwd()
[17:29:45.960]             }
[17:29:45.960]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:45.960]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:45.960]         }
[17:29:45.960]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:45.960]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:45.960]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:45.960]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:45.960]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:45.960]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:45.960]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:45.960]             base::names(...future.oldOptions))
[17:29:45.960]     }
[17:29:45.960]     if (FALSE) {
[17:29:45.960]     }
[17:29:45.960]     else {
[17:29:45.960]         if (TRUE) {
[17:29:45.960]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:45.960]                 open = "w")
[17:29:45.960]         }
[17:29:45.960]         else {
[17:29:45.960]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:45.960]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:45.960]         }
[17:29:45.960]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:45.960]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:45.960]             base::sink(type = "output", split = FALSE)
[17:29:45.960]             base::close(...future.stdout)
[17:29:45.960]         }, add = TRUE)
[17:29:45.960]     }
[17:29:45.960]     ...future.frame <- base::sys.nframe()
[17:29:45.960]     ...future.conditions <- base::list()
[17:29:45.960]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:45.960]     if (FALSE) {
[17:29:45.960]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:45.960]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:45.960]     }
[17:29:45.960]     ...future.result <- base::tryCatch({
[17:29:45.960]         base::withCallingHandlers({
[17:29:45.960]             ...future.value <- base::withVisible(base::local({
[17:29:45.960]                 ...future.makeSendCondition <- base::local({
[17:29:45.960]                   sendCondition <- NULL
[17:29:45.960]                   function(frame = 1L) {
[17:29:45.960]                     if (is.function(sendCondition)) 
[17:29:45.960]                       return(sendCondition)
[17:29:45.960]                     ns <- getNamespace("parallel")
[17:29:45.960]                     if (exists("sendData", mode = "function", 
[17:29:45.960]                       envir = ns)) {
[17:29:45.960]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:45.960]                         envir = ns)
[17:29:45.960]                       envir <- sys.frame(frame)
[17:29:45.960]                       master <- NULL
[17:29:45.960]                       while (!identical(envir, .GlobalEnv) && 
[17:29:45.960]                         !identical(envir, emptyenv())) {
[17:29:45.960]                         if (exists("master", mode = "list", envir = envir, 
[17:29:45.960]                           inherits = FALSE)) {
[17:29:45.960]                           master <- get("master", mode = "list", 
[17:29:45.960]                             envir = envir, inherits = FALSE)
[17:29:45.960]                           if (inherits(master, c("SOCKnode", 
[17:29:45.960]                             "SOCK0node"))) {
[17:29:45.960]                             sendCondition <<- function(cond) {
[17:29:45.960]                               data <- list(type = "VALUE", value = cond, 
[17:29:45.960]                                 success = TRUE)
[17:29:45.960]                               parallel_sendData(master, data)
[17:29:45.960]                             }
[17:29:45.960]                             return(sendCondition)
[17:29:45.960]                           }
[17:29:45.960]                         }
[17:29:45.960]                         frame <- frame + 1L
[17:29:45.960]                         envir <- sys.frame(frame)
[17:29:45.960]                       }
[17:29:45.960]                     }
[17:29:45.960]                     sendCondition <<- function(cond) NULL
[17:29:45.960]                   }
[17:29:45.960]                 })
[17:29:45.960]                 withCallingHandlers({
[17:29:45.960]                   {
[17:29:45.960]                     sample(x, size = 1L)
[17:29:45.960]                   }
[17:29:45.960]                 }, immediateCondition = function(cond) {
[17:29:45.960]                   sendCondition <- ...future.makeSendCondition()
[17:29:45.960]                   sendCondition(cond)
[17:29:45.960]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.960]                   {
[17:29:45.960]                     inherits <- base::inherits
[17:29:45.960]                     invokeRestart <- base::invokeRestart
[17:29:45.960]                     is.null <- base::is.null
[17:29:45.960]                     muffled <- FALSE
[17:29:45.960]                     if (inherits(cond, "message")) {
[17:29:45.960]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:45.960]                       if (muffled) 
[17:29:45.960]                         invokeRestart("muffleMessage")
[17:29:45.960]                     }
[17:29:45.960]                     else if (inherits(cond, "warning")) {
[17:29:45.960]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:45.960]                       if (muffled) 
[17:29:45.960]                         invokeRestart("muffleWarning")
[17:29:45.960]                     }
[17:29:45.960]                     else if (inherits(cond, "condition")) {
[17:29:45.960]                       if (!is.null(pattern)) {
[17:29:45.960]                         computeRestarts <- base::computeRestarts
[17:29:45.960]                         grepl <- base::grepl
[17:29:45.960]                         restarts <- computeRestarts(cond)
[17:29:45.960]                         for (restart in restarts) {
[17:29:45.960]                           name <- restart$name
[17:29:45.960]                           if (is.null(name)) 
[17:29:45.960]                             next
[17:29:45.960]                           if (!grepl(pattern, name)) 
[17:29:45.960]                             next
[17:29:45.960]                           invokeRestart(restart)
[17:29:45.960]                           muffled <- TRUE
[17:29:45.960]                           break
[17:29:45.960]                         }
[17:29:45.960]                       }
[17:29:45.960]                     }
[17:29:45.960]                     invisible(muffled)
[17:29:45.960]                   }
[17:29:45.960]                   muffleCondition(cond)
[17:29:45.960]                 })
[17:29:45.960]             }))
[17:29:45.960]             future::FutureResult(value = ...future.value$value, 
[17:29:45.960]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.960]                   ...future.rng), globalenv = if (FALSE) 
[17:29:45.960]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:45.960]                     ...future.globalenv.names))
[17:29:45.960]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:45.960]         }, condition = base::local({
[17:29:45.960]             c <- base::c
[17:29:45.960]             inherits <- base::inherits
[17:29:45.960]             invokeRestart <- base::invokeRestart
[17:29:45.960]             length <- base::length
[17:29:45.960]             list <- base::list
[17:29:45.960]             seq.int <- base::seq.int
[17:29:45.960]             signalCondition <- base::signalCondition
[17:29:45.960]             sys.calls <- base::sys.calls
[17:29:45.960]             `[[` <- base::`[[`
[17:29:45.960]             `+` <- base::`+`
[17:29:45.960]             `<<-` <- base::`<<-`
[17:29:45.960]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:45.960]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:45.960]                   3L)]
[17:29:45.960]             }
[17:29:45.960]             function(cond) {
[17:29:45.960]                 is_error <- inherits(cond, "error")
[17:29:45.960]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:45.960]                   NULL)
[17:29:45.960]                 if (is_error) {
[17:29:45.960]                   sessionInformation <- function() {
[17:29:45.960]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:45.960]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:45.960]                       search = base::search(), system = base::Sys.info())
[17:29:45.960]                   }
[17:29:45.960]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.960]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:45.960]                     cond$call), session = sessionInformation(), 
[17:29:45.960]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:45.960]                   signalCondition(cond)
[17:29:45.960]                 }
[17:29:45.960]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:45.960]                 "immediateCondition"))) {
[17:29:45.960]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:45.960]                   ...future.conditions[[length(...future.conditions) + 
[17:29:45.960]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:45.960]                   if (TRUE && !signal) {
[17:29:45.960]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.960]                     {
[17:29:45.960]                       inherits <- base::inherits
[17:29:45.960]                       invokeRestart <- base::invokeRestart
[17:29:45.960]                       is.null <- base::is.null
[17:29:45.960]                       muffled <- FALSE
[17:29:45.960]                       if (inherits(cond, "message")) {
[17:29:45.960]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.960]                         if (muffled) 
[17:29:45.960]                           invokeRestart("muffleMessage")
[17:29:45.960]                       }
[17:29:45.960]                       else if (inherits(cond, "warning")) {
[17:29:45.960]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.960]                         if (muffled) 
[17:29:45.960]                           invokeRestart("muffleWarning")
[17:29:45.960]                       }
[17:29:45.960]                       else if (inherits(cond, "condition")) {
[17:29:45.960]                         if (!is.null(pattern)) {
[17:29:45.960]                           computeRestarts <- base::computeRestarts
[17:29:45.960]                           grepl <- base::grepl
[17:29:45.960]                           restarts <- computeRestarts(cond)
[17:29:45.960]                           for (restart in restarts) {
[17:29:45.960]                             name <- restart$name
[17:29:45.960]                             if (is.null(name)) 
[17:29:45.960]                               next
[17:29:45.960]                             if (!grepl(pattern, name)) 
[17:29:45.960]                               next
[17:29:45.960]                             invokeRestart(restart)
[17:29:45.960]                             muffled <- TRUE
[17:29:45.960]                             break
[17:29:45.960]                           }
[17:29:45.960]                         }
[17:29:45.960]                       }
[17:29:45.960]                       invisible(muffled)
[17:29:45.960]                     }
[17:29:45.960]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.960]                   }
[17:29:45.960]                 }
[17:29:45.960]                 else {
[17:29:45.960]                   if (TRUE) {
[17:29:45.960]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:45.960]                     {
[17:29:45.960]                       inherits <- base::inherits
[17:29:45.960]                       invokeRestart <- base::invokeRestart
[17:29:45.960]                       is.null <- base::is.null
[17:29:45.960]                       muffled <- FALSE
[17:29:45.960]                       if (inherits(cond, "message")) {
[17:29:45.960]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:45.960]                         if (muffled) 
[17:29:45.960]                           invokeRestart("muffleMessage")
[17:29:45.960]                       }
[17:29:45.960]                       else if (inherits(cond, "warning")) {
[17:29:45.960]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:45.960]                         if (muffled) 
[17:29:45.960]                           invokeRestart("muffleWarning")
[17:29:45.960]                       }
[17:29:45.960]                       else if (inherits(cond, "condition")) {
[17:29:45.960]                         if (!is.null(pattern)) {
[17:29:45.960]                           computeRestarts <- base::computeRestarts
[17:29:45.960]                           grepl <- base::grepl
[17:29:45.960]                           restarts <- computeRestarts(cond)
[17:29:45.960]                           for (restart in restarts) {
[17:29:45.960]                             name <- restart$name
[17:29:45.960]                             if (is.null(name)) 
[17:29:45.960]                               next
[17:29:45.960]                             if (!grepl(pattern, name)) 
[17:29:45.960]                               next
[17:29:45.960]                             invokeRestart(restart)
[17:29:45.960]                             muffled <- TRUE
[17:29:45.960]                             break
[17:29:45.960]                           }
[17:29:45.960]                         }
[17:29:45.960]                       }
[17:29:45.960]                       invisible(muffled)
[17:29:45.960]                     }
[17:29:45.960]                     muffleCondition(cond, pattern = "^muffle")
[17:29:45.960]                   }
[17:29:45.960]                 }
[17:29:45.960]             }
[17:29:45.960]         }))
[17:29:45.960]     }, error = function(ex) {
[17:29:45.960]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:45.960]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:45.960]                 ...future.rng), started = ...future.startTime, 
[17:29:45.960]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:45.960]             version = "1.8"), class = "FutureResult")
[17:29:45.960]     }, finally = {
[17:29:45.960]         if (!identical(...future.workdir, getwd())) 
[17:29:45.960]             setwd(...future.workdir)
[17:29:45.960]         {
[17:29:45.960]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:45.960]                 ...future.oldOptions$nwarnings <- NULL
[17:29:45.960]             }
[17:29:45.960]             base::options(...future.oldOptions)
[17:29:45.960]             if (.Platform$OS.type == "windows") {
[17:29:45.960]                 old_names <- names(...future.oldEnvVars)
[17:29:45.960]                 envs <- base::Sys.getenv()
[17:29:45.960]                 names <- names(envs)
[17:29:45.960]                 common <- intersect(names, old_names)
[17:29:45.960]                 added <- setdiff(names, old_names)
[17:29:45.960]                 removed <- setdiff(old_names, names)
[17:29:45.960]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:45.960]                   envs[common]]
[17:29:45.960]                 NAMES <- toupper(changed)
[17:29:45.960]                 args <- list()
[17:29:45.960]                 for (kk in seq_along(NAMES)) {
[17:29:45.960]                   name <- changed[[kk]]
[17:29:45.960]                   NAME <- NAMES[[kk]]
[17:29:45.960]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.960]                     next
[17:29:45.960]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.960]                 }
[17:29:45.960]                 NAMES <- toupper(added)
[17:29:45.960]                 for (kk in seq_along(NAMES)) {
[17:29:45.960]                   name <- added[[kk]]
[17:29:45.960]                   NAME <- NAMES[[kk]]
[17:29:45.960]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.960]                     next
[17:29:45.960]                   args[[name]] <- ""
[17:29:45.960]                 }
[17:29:45.960]                 NAMES <- toupper(removed)
[17:29:45.960]                 for (kk in seq_along(NAMES)) {
[17:29:45.960]                   name <- removed[[kk]]
[17:29:45.960]                   NAME <- NAMES[[kk]]
[17:29:45.960]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:45.960]                     next
[17:29:45.960]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:45.960]                 }
[17:29:45.960]                 if (length(args) > 0) 
[17:29:45.960]                   base::do.call(base::Sys.setenv, args = args)
[17:29:45.960]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:45.960]             }
[17:29:45.960]             else {
[17:29:45.960]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:45.960]             }
[17:29:45.960]             {
[17:29:45.960]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:45.960]                   0L) {
[17:29:45.960]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:45.960]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:45.960]                   base::options(opts)
[17:29:45.960]                 }
[17:29:45.960]                 {
[17:29:45.960]                   {
[17:29:45.960]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:45.960]                     NULL
[17:29:45.960]                   }
[17:29:45.960]                   options(future.plan = NULL)
[17:29:45.960]                   if (is.na(NA_character_)) 
[17:29:45.960]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:45.960]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:45.960]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:45.960]                     .init = FALSE)
[17:29:45.960]                 }
[17:29:45.960]             }
[17:29:45.960]         }
[17:29:45.960]     })
[17:29:45.960]     if (TRUE) {
[17:29:45.960]         base::sink(type = "output", split = FALSE)
[17:29:45.960]         if (TRUE) {
[17:29:45.960]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:45.960]         }
[17:29:45.960]         else {
[17:29:45.960]             ...future.result["stdout"] <- base::list(NULL)
[17:29:45.960]         }
[17:29:45.960]         base::close(...future.stdout)
[17:29:45.960]         ...future.stdout <- NULL
[17:29:45.960]     }
[17:29:45.960]     ...future.result$conditions <- ...future.conditions
[17:29:45.960]     ...future.result$finished <- base::Sys.time()
[17:29:45.960]     ...future.result
[17:29:45.960] }
[17:29:45.968] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:45.968] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:45.969] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:45.969] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:45.970] MultisessionFuture started
[17:29:45.970] - Launch lazy future ... done
[17:29:45.971] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_2-979539'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001addb4a7098
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:29:46.000] receiveMessageFromWorker() for ClusterFuture ...
[17:29:46.001] - Validating connection of MultisessionFuture
[17:29:46.001] - received message: FutureResult
[17:29:46.002] - Received FutureResult
[17:29:46.002] - Erased future from FutureRegistry
[17:29:46.002] result() for ClusterFuture ...
[17:29:46.003] - result already collected: FutureResult
[17:29:46.003] result() for ClusterFuture ... done
[17:29:46.003] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.004] getGlobalsAndPackages() ...
[17:29:46.004] Searching for globals...
[17:29:46.005] - globals found: [3] '{', 'sample', 'x'
[17:29:46.005] Searching for globals ... DONE
[17:29:46.006] Resolving globals: FALSE
[17:29:46.006] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:46.007] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:46.007] - globals: [1] 'x'
[17:29:46.007] 
[17:29:46.007] getGlobalsAndPackages() ... DONE
[17:29:46.007] run() for 'Future' ...
[17:29:46.008] - state: 'created'
[17:29:46.008] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:46.023] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.023] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:46.024]   - Field: 'node'
[17:29:46.024]   - Field: 'label'
[17:29:46.024]   - Field: 'local'
[17:29:46.024]   - Field: 'owner'
[17:29:46.025]   - Field: 'envir'
[17:29:46.025]   - Field: 'workers'
[17:29:46.025]   - Field: 'packages'
[17:29:46.025]   - Field: 'gc'
[17:29:46.026]   - Field: 'conditions'
[17:29:46.026]   - Field: 'persistent'
[17:29:46.026]   - Field: 'expr'
[17:29:46.026]   - Field: 'uuid'
[17:29:46.027]   - Field: 'seed'
[17:29:46.027]   - Field: 'version'
[17:29:46.027]   - Field: 'result'
[17:29:46.027]   - Field: 'asynchronous'
[17:29:46.028]   - Field: 'calls'
[17:29:46.028]   - Field: 'globals'
[17:29:46.028]   - Field: 'stdout'
[17:29:46.028]   - Field: 'earlySignal'
[17:29:46.029]   - Field: 'lazy'
[17:29:46.029]   - Field: 'state'
[17:29:46.029] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:46.029] - Launch lazy future ...
[17:29:46.030] Packages needed by the future expression (n = 0): <none>
[17:29:46.030] Packages needed by future strategies (n = 0): <none>
[17:29:46.031] {
[17:29:46.031]     {
[17:29:46.031]         {
[17:29:46.031]             ...future.startTime <- base::Sys.time()
[17:29:46.031]             {
[17:29:46.031]                 {
[17:29:46.031]                   {
[17:29:46.031]                     {
[17:29:46.031]                       base::local({
[17:29:46.031]                         has_future <- base::requireNamespace("future", 
[17:29:46.031]                           quietly = TRUE)
[17:29:46.031]                         if (has_future) {
[17:29:46.031]                           ns <- base::getNamespace("future")
[17:29:46.031]                           version <- ns[[".package"]][["version"]]
[17:29:46.031]                           if (is.null(version)) 
[17:29:46.031]                             version <- utils::packageVersion("future")
[17:29:46.031]                         }
[17:29:46.031]                         else {
[17:29:46.031]                           version <- NULL
[17:29:46.031]                         }
[17:29:46.031]                         if (!has_future || version < "1.8.0") {
[17:29:46.031]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:46.031]                             "", base::R.version$version.string), 
[17:29:46.031]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:46.031]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:46.031]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:46.031]                               "release", "version")], collapse = " "), 
[17:29:46.031]                             hostname = base::Sys.info()[["nodename"]])
[17:29:46.031]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:46.031]                             info)
[17:29:46.031]                           info <- base::paste(info, collapse = "; ")
[17:29:46.031]                           if (!has_future) {
[17:29:46.031]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:46.031]                               info)
[17:29:46.031]                           }
[17:29:46.031]                           else {
[17:29:46.031]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:46.031]                               info, version)
[17:29:46.031]                           }
[17:29:46.031]                           base::stop(msg)
[17:29:46.031]                         }
[17:29:46.031]                       })
[17:29:46.031]                     }
[17:29:46.031]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:46.031]                     base::options(mc.cores = 1L)
[17:29:46.031]                   }
[17:29:46.031]                   ...future.strategy.old <- future::plan("list")
[17:29:46.031]                   options(future.plan = NULL)
[17:29:46.031]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.031]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:46.031]                 }
[17:29:46.031]                 ...future.workdir <- getwd()
[17:29:46.031]             }
[17:29:46.031]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:46.031]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:46.031]         }
[17:29:46.031]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:46.031]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:46.031]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:46.031]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:46.031]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:46.031]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:46.031]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:46.031]             base::names(...future.oldOptions))
[17:29:46.031]     }
[17:29:46.031]     if (FALSE) {
[17:29:46.031]     }
[17:29:46.031]     else {
[17:29:46.031]         if (TRUE) {
[17:29:46.031]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:46.031]                 open = "w")
[17:29:46.031]         }
[17:29:46.031]         else {
[17:29:46.031]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:46.031]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:46.031]         }
[17:29:46.031]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:46.031]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:46.031]             base::sink(type = "output", split = FALSE)
[17:29:46.031]             base::close(...future.stdout)
[17:29:46.031]         }, add = TRUE)
[17:29:46.031]     }
[17:29:46.031]     ...future.frame <- base::sys.nframe()
[17:29:46.031]     ...future.conditions <- base::list()
[17:29:46.031]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:46.031]     if (FALSE) {
[17:29:46.031]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:46.031]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:46.031]     }
[17:29:46.031]     ...future.result <- base::tryCatch({
[17:29:46.031]         base::withCallingHandlers({
[17:29:46.031]             ...future.value <- base::withVisible(base::local({
[17:29:46.031]                 ...future.makeSendCondition <- base::local({
[17:29:46.031]                   sendCondition <- NULL
[17:29:46.031]                   function(frame = 1L) {
[17:29:46.031]                     if (is.function(sendCondition)) 
[17:29:46.031]                       return(sendCondition)
[17:29:46.031]                     ns <- getNamespace("parallel")
[17:29:46.031]                     if (exists("sendData", mode = "function", 
[17:29:46.031]                       envir = ns)) {
[17:29:46.031]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:46.031]                         envir = ns)
[17:29:46.031]                       envir <- sys.frame(frame)
[17:29:46.031]                       master <- NULL
[17:29:46.031]                       while (!identical(envir, .GlobalEnv) && 
[17:29:46.031]                         !identical(envir, emptyenv())) {
[17:29:46.031]                         if (exists("master", mode = "list", envir = envir, 
[17:29:46.031]                           inherits = FALSE)) {
[17:29:46.031]                           master <- get("master", mode = "list", 
[17:29:46.031]                             envir = envir, inherits = FALSE)
[17:29:46.031]                           if (inherits(master, c("SOCKnode", 
[17:29:46.031]                             "SOCK0node"))) {
[17:29:46.031]                             sendCondition <<- function(cond) {
[17:29:46.031]                               data <- list(type = "VALUE", value = cond, 
[17:29:46.031]                                 success = TRUE)
[17:29:46.031]                               parallel_sendData(master, data)
[17:29:46.031]                             }
[17:29:46.031]                             return(sendCondition)
[17:29:46.031]                           }
[17:29:46.031]                         }
[17:29:46.031]                         frame <- frame + 1L
[17:29:46.031]                         envir <- sys.frame(frame)
[17:29:46.031]                       }
[17:29:46.031]                     }
[17:29:46.031]                     sendCondition <<- function(cond) NULL
[17:29:46.031]                   }
[17:29:46.031]                 })
[17:29:46.031]                 withCallingHandlers({
[17:29:46.031]                   {
[17:29:46.031]                     sample(x, size = 1L)
[17:29:46.031]                   }
[17:29:46.031]                 }, immediateCondition = function(cond) {
[17:29:46.031]                   sendCondition <- ...future.makeSendCondition()
[17:29:46.031]                   sendCondition(cond)
[17:29:46.031]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.031]                   {
[17:29:46.031]                     inherits <- base::inherits
[17:29:46.031]                     invokeRestart <- base::invokeRestart
[17:29:46.031]                     is.null <- base::is.null
[17:29:46.031]                     muffled <- FALSE
[17:29:46.031]                     if (inherits(cond, "message")) {
[17:29:46.031]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:46.031]                       if (muffled) 
[17:29:46.031]                         invokeRestart("muffleMessage")
[17:29:46.031]                     }
[17:29:46.031]                     else if (inherits(cond, "warning")) {
[17:29:46.031]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:46.031]                       if (muffled) 
[17:29:46.031]                         invokeRestart("muffleWarning")
[17:29:46.031]                     }
[17:29:46.031]                     else if (inherits(cond, "condition")) {
[17:29:46.031]                       if (!is.null(pattern)) {
[17:29:46.031]                         computeRestarts <- base::computeRestarts
[17:29:46.031]                         grepl <- base::grepl
[17:29:46.031]                         restarts <- computeRestarts(cond)
[17:29:46.031]                         for (restart in restarts) {
[17:29:46.031]                           name <- restart$name
[17:29:46.031]                           if (is.null(name)) 
[17:29:46.031]                             next
[17:29:46.031]                           if (!grepl(pattern, name)) 
[17:29:46.031]                             next
[17:29:46.031]                           invokeRestart(restart)
[17:29:46.031]                           muffled <- TRUE
[17:29:46.031]                           break
[17:29:46.031]                         }
[17:29:46.031]                       }
[17:29:46.031]                     }
[17:29:46.031]                     invisible(muffled)
[17:29:46.031]                   }
[17:29:46.031]                   muffleCondition(cond)
[17:29:46.031]                 })
[17:29:46.031]             }))
[17:29:46.031]             future::FutureResult(value = ...future.value$value, 
[17:29:46.031]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.031]                   ...future.rng), globalenv = if (FALSE) 
[17:29:46.031]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:46.031]                     ...future.globalenv.names))
[17:29:46.031]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:46.031]         }, condition = base::local({
[17:29:46.031]             c <- base::c
[17:29:46.031]             inherits <- base::inherits
[17:29:46.031]             invokeRestart <- base::invokeRestart
[17:29:46.031]             length <- base::length
[17:29:46.031]             list <- base::list
[17:29:46.031]             seq.int <- base::seq.int
[17:29:46.031]             signalCondition <- base::signalCondition
[17:29:46.031]             sys.calls <- base::sys.calls
[17:29:46.031]             `[[` <- base::`[[`
[17:29:46.031]             `+` <- base::`+`
[17:29:46.031]             `<<-` <- base::`<<-`
[17:29:46.031]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:46.031]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:46.031]                   3L)]
[17:29:46.031]             }
[17:29:46.031]             function(cond) {
[17:29:46.031]                 is_error <- inherits(cond, "error")
[17:29:46.031]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:46.031]                   NULL)
[17:29:46.031]                 if (is_error) {
[17:29:46.031]                   sessionInformation <- function() {
[17:29:46.031]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:46.031]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:46.031]                       search = base::search(), system = base::Sys.info())
[17:29:46.031]                   }
[17:29:46.031]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.031]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:46.031]                     cond$call), session = sessionInformation(), 
[17:29:46.031]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:46.031]                   signalCondition(cond)
[17:29:46.031]                 }
[17:29:46.031]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:46.031]                 "immediateCondition"))) {
[17:29:46.031]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:46.031]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.031]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:46.031]                   if (TRUE && !signal) {
[17:29:46.031]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.031]                     {
[17:29:46.031]                       inherits <- base::inherits
[17:29:46.031]                       invokeRestart <- base::invokeRestart
[17:29:46.031]                       is.null <- base::is.null
[17:29:46.031]                       muffled <- FALSE
[17:29:46.031]                       if (inherits(cond, "message")) {
[17:29:46.031]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.031]                         if (muffled) 
[17:29:46.031]                           invokeRestart("muffleMessage")
[17:29:46.031]                       }
[17:29:46.031]                       else if (inherits(cond, "warning")) {
[17:29:46.031]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.031]                         if (muffled) 
[17:29:46.031]                           invokeRestart("muffleWarning")
[17:29:46.031]                       }
[17:29:46.031]                       else if (inherits(cond, "condition")) {
[17:29:46.031]                         if (!is.null(pattern)) {
[17:29:46.031]                           computeRestarts <- base::computeRestarts
[17:29:46.031]                           grepl <- base::grepl
[17:29:46.031]                           restarts <- computeRestarts(cond)
[17:29:46.031]                           for (restart in restarts) {
[17:29:46.031]                             name <- restart$name
[17:29:46.031]                             if (is.null(name)) 
[17:29:46.031]                               next
[17:29:46.031]                             if (!grepl(pattern, name)) 
[17:29:46.031]                               next
[17:29:46.031]                             invokeRestart(restart)
[17:29:46.031]                             muffled <- TRUE
[17:29:46.031]                             break
[17:29:46.031]                           }
[17:29:46.031]                         }
[17:29:46.031]                       }
[17:29:46.031]                       invisible(muffled)
[17:29:46.031]                     }
[17:29:46.031]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.031]                   }
[17:29:46.031]                 }
[17:29:46.031]                 else {
[17:29:46.031]                   if (TRUE) {
[17:29:46.031]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.031]                     {
[17:29:46.031]                       inherits <- base::inherits
[17:29:46.031]                       invokeRestart <- base::invokeRestart
[17:29:46.031]                       is.null <- base::is.null
[17:29:46.031]                       muffled <- FALSE
[17:29:46.031]                       if (inherits(cond, "message")) {
[17:29:46.031]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.031]                         if (muffled) 
[17:29:46.031]                           invokeRestart("muffleMessage")
[17:29:46.031]                       }
[17:29:46.031]                       else if (inherits(cond, "warning")) {
[17:29:46.031]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.031]                         if (muffled) 
[17:29:46.031]                           invokeRestart("muffleWarning")
[17:29:46.031]                       }
[17:29:46.031]                       else if (inherits(cond, "condition")) {
[17:29:46.031]                         if (!is.null(pattern)) {
[17:29:46.031]                           computeRestarts <- base::computeRestarts
[17:29:46.031]                           grepl <- base::grepl
[17:29:46.031]                           restarts <- computeRestarts(cond)
[17:29:46.031]                           for (restart in restarts) {
[17:29:46.031]                             name <- restart$name
[17:29:46.031]                             if (is.null(name)) 
[17:29:46.031]                               next
[17:29:46.031]                             if (!grepl(pattern, name)) 
[17:29:46.031]                               next
[17:29:46.031]                             invokeRestart(restart)
[17:29:46.031]                             muffled <- TRUE
[17:29:46.031]                             break
[17:29:46.031]                           }
[17:29:46.031]                         }
[17:29:46.031]                       }
[17:29:46.031]                       invisible(muffled)
[17:29:46.031]                     }
[17:29:46.031]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.031]                   }
[17:29:46.031]                 }
[17:29:46.031]             }
[17:29:46.031]         }))
[17:29:46.031]     }, error = function(ex) {
[17:29:46.031]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:46.031]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.031]                 ...future.rng), started = ...future.startTime, 
[17:29:46.031]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:46.031]             version = "1.8"), class = "FutureResult")
[17:29:46.031]     }, finally = {
[17:29:46.031]         if (!identical(...future.workdir, getwd())) 
[17:29:46.031]             setwd(...future.workdir)
[17:29:46.031]         {
[17:29:46.031]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:46.031]                 ...future.oldOptions$nwarnings <- NULL
[17:29:46.031]             }
[17:29:46.031]             base::options(...future.oldOptions)
[17:29:46.031]             if (.Platform$OS.type == "windows") {
[17:29:46.031]                 old_names <- names(...future.oldEnvVars)
[17:29:46.031]                 envs <- base::Sys.getenv()
[17:29:46.031]                 names <- names(envs)
[17:29:46.031]                 common <- intersect(names, old_names)
[17:29:46.031]                 added <- setdiff(names, old_names)
[17:29:46.031]                 removed <- setdiff(old_names, names)
[17:29:46.031]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:46.031]                   envs[common]]
[17:29:46.031]                 NAMES <- toupper(changed)
[17:29:46.031]                 args <- list()
[17:29:46.031]                 for (kk in seq_along(NAMES)) {
[17:29:46.031]                   name <- changed[[kk]]
[17:29:46.031]                   NAME <- NAMES[[kk]]
[17:29:46.031]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.031]                     next
[17:29:46.031]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.031]                 }
[17:29:46.031]                 NAMES <- toupper(added)
[17:29:46.031]                 for (kk in seq_along(NAMES)) {
[17:29:46.031]                   name <- added[[kk]]
[17:29:46.031]                   NAME <- NAMES[[kk]]
[17:29:46.031]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.031]                     next
[17:29:46.031]                   args[[name]] <- ""
[17:29:46.031]                 }
[17:29:46.031]                 NAMES <- toupper(removed)
[17:29:46.031]                 for (kk in seq_along(NAMES)) {
[17:29:46.031]                   name <- removed[[kk]]
[17:29:46.031]                   NAME <- NAMES[[kk]]
[17:29:46.031]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.031]                     next
[17:29:46.031]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.031]                 }
[17:29:46.031]                 if (length(args) > 0) 
[17:29:46.031]                   base::do.call(base::Sys.setenv, args = args)
[17:29:46.031]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:46.031]             }
[17:29:46.031]             else {
[17:29:46.031]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:46.031]             }
[17:29:46.031]             {
[17:29:46.031]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:46.031]                   0L) {
[17:29:46.031]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:46.031]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:46.031]                   base::options(opts)
[17:29:46.031]                 }
[17:29:46.031]                 {
[17:29:46.031]                   {
[17:29:46.031]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:46.031]                     NULL
[17:29:46.031]                   }
[17:29:46.031]                   options(future.plan = NULL)
[17:29:46.031]                   if (is.na(NA_character_)) 
[17:29:46.031]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.031]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:46.031]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:46.031]                     .init = FALSE)
[17:29:46.031]                 }
[17:29:46.031]             }
[17:29:46.031]         }
[17:29:46.031]     })
[17:29:46.031]     if (TRUE) {
[17:29:46.031]         base::sink(type = "output", split = FALSE)
[17:29:46.031]         if (TRUE) {
[17:29:46.031]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:46.031]         }
[17:29:46.031]         else {
[17:29:46.031]             ...future.result["stdout"] <- base::list(NULL)
[17:29:46.031]         }
[17:29:46.031]         base::close(...future.stdout)
[17:29:46.031]         ...future.stdout <- NULL
[17:29:46.031]     }
[17:29:46.031]     ...future.result$conditions <- ...future.conditions
[17:29:46.031]     ...future.result$finished <- base::Sys.time()
[17:29:46.031]     ...future.result
[17:29:46.031] }
[17:29:46.039] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:46.039] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:46.040] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:46.040] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:46.041] MultisessionFuture started
[17:29:46.042] - Launch lazy future ... done
[17:29:46.042] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_3-405479'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001addb4a7098
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:29:46.066] receiveMessageFromWorker() for ClusterFuture ...
[17:29:46.067] - Validating connection of MultisessionFuture
[17:29:46.067] - received message: FutureResult
[17:29:46.068] - Received FutureResult
[17:29:46.068] - Erased future from FutureRegistry
[17:29:46.068] result() for ClusterFuture ...
[17:29:46.068] - result already collected: FutureResult
[17:29:46.069] result() for ClusterFuture ... done
[17:29:46.069] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.069] getGlobalsAndPackages() ...
[17:29:46.069] Searching for globals...
[17:29:46.071] - globals found: [3] '{', 'sample', 'x'
[17:29:46.071] Searching for globals ... DONE
[17:29:46.072] Resolving globals: FALSE
[17:29:46.072] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:46.073] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:46.073] - globals: [1] 'x'
[17:29:46.073] 
[17:29:46.074] getGlobalsAndPackages() ... DONE
[17:29:46.074] run() for 'Future' ...
[17:29:46.074] - state: 'created'
[17:29:46.075] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:46.092] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.093] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:46.093]   - Field: 'node'
[17:29:46.093]   - Field: 'label'
[17:29:46.094]   - Field: 'local'
[17:29:46.094]   - Field: 'owner'
[17:29:46.094]   - Field: 'envir'
[17:29:46.094]   - Field: 'workers'
[17:29:46.095]   - Field: 'packages'
[17:29:46.095]   - Field: 'gc'
[17:29:46.095]   - Field: 'conditions'
[17:29:46.096]   - Field: 'persistent'
[17:29:46.096]   - Field: 'expr'
[17:29:46.096]   - Field: 'uuid'
[17:29:46.096]   - Field: 'seed'
[17:29:46.097]   - Field: 'version'
[17:29:46.097]   - Field: 'result'
[17:29:46.097]   - Field: 'asynchronous'
[17:29:46.098]   - Field: 'calls'
[17:29:46.098]   - Field: 'globals'
[17:29:46.098]   - Field: 'stdout'
[17:29:46.098]   - Field: 'earlySignal'
[17:29:46.099]   - Field: 'lazy'
[17:29:46.099]   - Field: 'state'
[17:29:46.099] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:46.099] - Launch lazy future ...
[17:29:46.100] Packages needed by the future expression (n = 0): <none>
[17:29:46.100] Packages needed by future strategies (n = 0): <none>
[17:29:46.101] {
[17:29:46.101]     {
[17:29:46.101]         {
[17:29:46.101]             ...future.startTime <- base::Sys.time()
[17:29:46.101]             {
[17:29:46.101]                 {
[17:29:46.101]                   {
[17:29:46.101]                     {
[17:29:46.101]                       base::local({
[17:29:46.101]                         has_future <- base::requireNamespace("future", 
[17:29:46.101]                           quietly = TRUE)
[17:29:46.101]                         if (has_future) {
[17:29:46.101]                           ns <- base::getNamespace("future")
[17:29:46.101]                           version <- ns[[".package"]][["version"]]
[17:29:46.101]                           if (is.null(version)) 
[17:29:46.101]                             version <- utils::packageVersion("future")
[17:29:46.101]                         }
[17:29:46.101]                         else {
[17:29:46.101]                           version <- NULL
[17:29:46.101]                         }
[17:29:46.101]                         if (!has_future || version < "1.8.0") {
[17:29:46.101]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:46.101]                             "", base::R.version$version.string), 
[17:29:46.101]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:46.101]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:46.101]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:46.101]                               "release", "version")], collapse = " "), 
[17:29:46.101]                             hostname = base::Sys.info()[["nodename"]])
[17:29:46.101]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:46.101]                             info)
[17:29:46.101]                           info <- base::paste(info, collapse = "; ")
[17:29:46.101]                           if (!has_future) {
[17:29:46.101]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:46.101]                               info)
[17:29:46.101]                           }
[17:29:46.101]                           else {
[17:29:46.101]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:46.101]                               info, version)
[17:29:46.101]                           }
[17:29:46.101]                           base::stop(msg)
[17:29:46.101]                         }
[17:29:46.101]                       })
[17:29:46.101]                     }
[17:29:46.101]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:46.101]                     base::options(mc.cores = 1L)
[17:29:46.101]                   }
[17:29:46.101]                   ...future.strategy.old <- future::plan("list")
[17:29:46.101]                   options(future.plan = NULL)
[17:29:46.101]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.101]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:46.101]                 }
[17:29:46.101]                 ...future.workdir <- getwd()
[17:29:46.101]             }
[17:29:46.101]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:46.101]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:46.101]         }
[17:29:46.101]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:46.101]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:46.101]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:46.101]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:46.101]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:46.101]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:46.101]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:46.101]             base::names(...future.oldOptions))
[17:29:46.101]     }
[17:29:46.101]     if (FALSE) {
[17:29:46.101]     }
[17:29:46.101]     else {
[17:29:46.101]         if (TRUE) {
[17:29:46.101]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:46.101]                 open = "w")
[17:29:46.101]         }
[17:29:46.101]         else {
[17:29:46.101]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:46.101]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:46.101]         }
[17:29:46.101]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:46.101]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:46.101]             base::sink(type = "output", split = FALSE)
[17:29:46.101]             base::close(...future.stdout)
[17:29:46.101]         }, add = TRUE)
[17:29:46.101]     }
[17:29:46.101]     ...future.frame <- base::sys.nframe()
[17:29:46.101]     ...future.conditions <- base::list()
[17:29:46.101]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:46.101]     if (FALSE) {
[17:29:46.101]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:46.101]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:46.101]     }
[17:29:46.101]     ...future.result <- base::tryCatch({
[17:29:46.101]         base::withCallingHandlers({
[17:29:46.101]             ...future.value <- base::withVisible(base::local({
[17:29:46.101]                 ...future.makeSendCondition <- base::local({
[17:29:46.101]                   sendCondition <- NULL
[17:29:46.101]                   function(frame = 1L) {
[17:29:46.101]                     if (is.function(sendCondition)) 
[17:29:46.101]                       return(sendCondition)
[17:29:46.101]                     ns <- getNamespace("parallel")
[17:29:46.101]                     if (exists("sendData", mode = "function", 
[17:29:46.101]                       envir = ns)) {
[17:29:46.101]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:46.101]                         envir = ns)
[17:29:46.101]                       envir <- sys.frame(frame)
[17:29:46.101]                       master <- NULL
[17:29:46.101]                       while (!identical(envir, .GlobalEnv) && 
[17:29:46.101]                         !identical(envir, emptyenv())) {
[17:29:46.101]                         if (exists("master", mode = "list", envir = envir, 
[17:29:46.101]                           inherits = FALSE)) {
[17:29:46.101]                           master <- get("master", mode = "list", 
[17:29:46.101]                             envir = envir, inherits = FALSE)
[17:29:46.101]                           if (inherits(master, c("SOCKnode", 
[17:29:46.101]                             "SOCK0node"))) {
[17:29:46.101]                             sendCondition <<- function(cond) {
[17:29:46.101]                               data <- list(type = "VALUE", value = cond, 
[17:29:46.101]                                 success = TRUE)
[17:29:46.101]                               parallel_sendData(master, data)
[17:29:46.101]                             }
[17:29:46.101]                             return(sendCondition)
[17:29:46.101]                           }
[17:29:46.101]                         }
[17:29:46.101]                         frame <- frame + 1L
[17:29:46.101]                         envir <- sys.frame(frame)
[17:29:46.101]                       }
[17:29:46.101]                     }
[17:29:46.101]                     sendCondition <<- function(cond) NULL
[17:29:46.101]                   }
[17:29:46.101]                 })
[17:29:46.101]                 withCallingHandlers({
[17:29:46.101]                   {
[17:29:46.101]                     sample(x, size = 1L)
[17:29:46.101]                   }
[17:29:46.101]                 }, immediateCondition = function(cond) {
[17:29:46.101]                   sendCondition <- ...future.makeSendCondition()
[17:29:46.101]                   sendCondition(cond)
[17:29:46.101]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.101]                   {
[17:29:46.101]                     inherits <- base::inherits
[17:29:46.101]                     invokeRestart <- base::invokeRestart
[17:29:46.101]                     is.null <- base::is.null
[17:29:46.101]                     muffled <- FALSE
[17:29:46.101]                     if (inherits(cond, "message")) {
[17:29:46.101]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:46.101]                       if (muffled) 
[17:29:46.101]                         invokeRestart("muffleMessage")
[17:29:46.101]                     }
[17:29:46.101]                     else if (inherits(cond, "warning")) {
[17:29:46.101]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:46.101]                       if (muffled) 
[17:29:46.101]                         invokeRestart("muffleWarning")
[17:29:46.101]                     }
[17:29:46.101]                     else if (inherits(cond, "condition")) {
[17:29:46.101]                       if (!is.null(pattern)) {
[17:29:46.101]                         computeRestarts <- base::computeRestarts
[17:29:46.101]                         grepl <- base::grepl
[17:29:46.101]                         restarts <- computeRestarts(cond)
[17:29:46.101]                         for (restart in restarts) {
[17:29:46.101]                           name <- restart$name
[17:29:46.101]                           if (is.null(name)) 
[17:29:46.101]                             next
[17:29:46.101]                           if (!grepl(pattern, name)) 
[17:29:46.101]                             next
[17:29:46.101]                           invokeRestart(restart)
[17:29:46.101]                           muffled <- TRUE
[17:29:46.101]                           break
[17:29:46.101]                         }
[17:29:46.101]                       }
[17:29:46.101]                     }
[17:29:46.101]                     invisible(muffled)
[17:29:46.101]                   }
[17:29:46.101]                   muffleCondition(cond)
[17:29:46.101]                 })
[17:29:46.101]             }))
[17:29:46.101]             future::FutureResult(value = ...future.value$value, 
[17:29:46.101]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.101]                   ...future.rng), globalenv = if (FALSE) 
[17:29:46.101]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:46.101]                     ...future.globalenv.names))
[17:29:46.101]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:46.101]         }, condition = base::local({
[17:29:46.101]             c <- base::c
[17:29:46.101]             inherits <- base::inherits
[17:29:46.101]             invokeRestart <- base::invokeRestart
[17:29:46.101]             length <- base::length
[17:29:46.101]             list <- base::list
[17:29:46.101]             seq.int <- base::seq.int
[17:29:46.101]             signalCondition <- base::signalCondition
[17:29:46.101]             sys.calls <- base::sys.calls
[17:29:46.101]             `[[` <- base::`[[`
[17:29:46.101]             `+` <- base::`+`
[17:29:46.101]             `<<-` <- base::`<<-`
[17:29:46.101]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:46.101]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:46.101]                   3L)]
[17:29:46.101]             }
[17:29:46.101]             function(cond) {
[17:29:46.101]                 is_error <- inherits(cond, "error")
[17:29:46.101]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:46.101]                   NULL)
[17:29:46.101]                 if (is_error) {
[17:29:46.101]                   sessionInformation <- function() {
[17:29:46.101]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:46.101]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:46.101]                       search = base::search(), system = base::Sys.info())
[17:29:46.101]                   }
[17:29:46.101]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.101]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:46.101]                     cond$call), session = sessionInformation(), 
[17:29:46.101]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:46.101]                   signalCondition(cond)
[17:29:46.101]                 }
[17:29:46.101]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:46.101]                 "immediateCondition"))) {
[17:29:46.101]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:46.101]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.101]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:46.101]                   if (TRUE && !signal) {
[17:29:46.101]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.101]                     {
[17:29:46.101]                       inherits <- base::inherits
[17:29:46.101]                       invokeRestart <- base::invokeRestart
[17:29:46.101]                       is.null <- base::is.null
[17:29:46.101]                       muffled <- FALSE
[17:29:46.101]                       if (inherits(cond, "message")) {
[17:29:46.101]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.101]                         if (muffled) 
[17:29:46.101]                           invokeRestart("muffleMessage")
[17:29:46.101]                       }
[17:29:46.101]                       else if (inherits(cond, "warning")) {
[17:29:46.101]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.101]                         if (muffled) 
[17:29:46.101]                           invokeRestart("muffleWarning")
[17:29:46.101]                       }
[17:29:46.101]                       else if (inherits(cond, "condition")) {
[17:29:46.101]                         if (!is.null(pattern)) {
[17:29:46.101]                           computeRestarts <- base::computeRestarts
[17:29:46.101]                           grepl <- base::grepl
[17:29:46.101]                           restarts <- computeRestarts(cond)
[17:29:46.101]                           for (restart in restarts) {
[17:29:46.101]                             name <- restart$name
[17:29:46.101]                             if (is.null(name)) 
[17:29:46.101]                               next
[17:29:46.101]                             if (!grepl(pattern, name)) 
[17:29:46.101]                               next
[17:29:46.101]                             invokeRestart(restart)
[17:29:46.101]                             muffled <- TRUE
[17:29:46.101]                             break
[17:29:46.101]                           }
[17:29:46.101]                         }
[17:29:46.101]                       }
[17:29:46.101]                       invisible(muffled)
[17:29:46.101]                     }
[17:29:46.101]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.101]                   }
[17:29:46.101]                 }
[17:29:46.101]                 else {
[17:29:46.101]                   if (TRUE) {
[17:29:46.101]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.101]                     {
[17:29:46.101]                       inherits <- base::inherits
[17:29:46.101]                       invokeRestart <- base::invokeRestart
[17:29:46.101]                       is.null <- base::is.null
[17:29:46.101]                       muffled <- FALSE
[17:29:46.101]                       if (inherits(cond, "message")) {
[17:29:46.101]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.101]                         if (muffled) 
[17:29:46.101]                           invokeRestart("muffleMessage")
[17:29:46.101]                       }
[17:29:46.101]                       else if (inherits(cond, "warning")) {
[17:29:46.101]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.101]                         if (muffled) 
[17:29:46.101]                           invokeRestart("muffleWarning")
[17:29:46.101]                       }
[17:29:46.101]                       else if (inherits(cond, "condition")) {
[17:29:46.101]                         if (!is.null(pattern)) {
[17:29:46.101]                           computeRestarts <- base::computeRestarts
[17:29:46.101]                           grepl <- base::grepl
[17:29:46.101]                           restarts <- computeRestarts(cond)
[17:29:46.101]                           for (restart in restarts) {
[17:29:46.101]                             name <- restart$name
[17:29:46.101]                             if (is.null(name)) 
[17:29:46.101]                               next
[17:29:46.101]                             if (!grepl(pattern, name)) 
[17:29:46.101]                               next
[17:29:46.101]                             invokeRestart(restart)
[17:29:46.101]                             muffled <- TRUE
[17:29:46.101]                             break
[17:29:46.101]                           }
[17:29:46.101]                         }
[17:29:46.101]                       }
[17:29:46.101]                       invisible(muffled)
[17:29:46.101]                     }
[17:29:46.101]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.101]                   }
[17:29:46.101]                 }
[17:29:46.101]             }
[17:29:46.101]         }))
[17:29:46.101]     }, error = function(ex) {
[17:29:46.101]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:46.101]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.101]                 ...future.rng), started = ...future.startTime, 
[17:29:46.101]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:46.101]             version = "1.8"), class = "FutureResult")
[17:29:46.101]     }, finally = {
[17:29:46.101]         if (!identical(...future.workdir, getwd())) 
[17:29:46.101]             setwd(...future.workdir)
[17:29:46.101]         {
[17:29:46.101]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:46.101]                 ...future.oldOptions$nwarnings <- NULL
[17:29:46.101]             }
[17:29:46.101]             base::options(...future.oldOptions)
[17:29:46.101]             if (.Platform$OS.type == "windows") {
[17:29:46.101]                 old_names <- names(...future.oldEnvVars)
[17:29:46.101]                 envs <- base::Sys.getenv()
[17:29:46.101]                 names <- names(envs)
[17:29:46.101]                 common <- intersect(names, old_names)
[17:29:46.101]                 added <- setdiff(names, old_names)
[17:29:46.101]                 removed <- setdiff(old_names, names)
[17:29:46.101]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:46.101]                   envs[common]]
[17:29:46.101]                 NAMES <- toupper(changed)
[17:29:46.101]                 args <- list()
[17:29:46.101]                 for (kk in seq_along(NAMES)) {
[17:29:46.101]                   name <- changed[[kk]]
[17:29:46.101]                   NAME <- NAMES[[kk]]
[17:29:46.101]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.101]                     next
[17:29:46.101]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.101]                 }
[17:29:46.101]                 NAMES <- toupper(added)
[17:29:46.101]                 for (kk in seq_along(NAMES)) {
[17:29:46.101]                   name <- added[[kk]]
[17:29:46.101]                   NAME <- NAMES[[kk]]
[17:29:46.101]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.101]                     next
[17:29:46.101]                   args[[name]] <- ""
[17:29:46.101]                 }
[17:29:46.101]                 NAMES <- toupper(removed)
[17:29:46.101]                 for (kk in seq_along(NAMES)) {
[17:29:46.101]                   name <- removed[[kk]]
[17:29:46.101]                   NAME <- NAMES[[kk]]
[17:29:46.101]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.101]                     next
[17:29:46.101]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.101]                 }
[17:29:46.101]                 if (length(args) > 0) 
[17:29:46.101]                   base::do.call(base::Sys.setenv, args = args)
[17:29:46.101]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:46.101]             }
[17:29:46.101]             else {
[17:29:46.101]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:46.101]             }
[17:29:46.101]             {
[17:29:46.101]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:46.101]                   0L) {
[17:29:46.101]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:46.101]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:46.101]                   base::options(opts)
[17:29:46.101]                 }
[17:29:46.101]                 {
[17:29:46.101]                   {
[17:29:46.101]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:46.101]                     NULL
[17:29:46.101]                   }
[17:29:46.101]                   options(future.plan = NULL)
[17:29:46.101]                   if (is.na(NA_character_)) 
[17:29:46.101]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.101]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:46.101]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:46.101]                     .init = FALSE)
[17:29:46.101]                 }
[17:29:46.101]             }
[17:29:46.101]         }
[17:29:46.101]     })
[17:29:46.101]     if (TRUE) {
[17:29:46.101]         base::sink(type = "output", split = FALSE)
[17:29:46.101]         if (TRUE) {
[17:29:46.101]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:46.101]         }
[17:29:46.101]         else {
[17:29:46.101]             ...future.result["stdout"] <- base::list(NULL)
[17:29:46.101]         }
[17:29:46.101]         base::close(...future.stdout)
[17:29:46.101]         ...future.stdout <- NULL
[17:29:46.101]     }
[17:29:46.101]     ...future.result$conditions <- ...future.conditions
[17:29:46.101]     ...future.result$finished <- base::Sys.time()
[17:29:46.101]     ...future.result
[17:29:46.101] }
[17:29:46.109] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:46.109] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:46.110] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:46.110] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:46.111] MultisessionFuture started
[17:29:46.111] - Launch lazy future ... done
[17:29:46.111] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_4-316964'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001addb4a7098
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:29:46.138] receiveMessageFromWorker() for ClusterFuture ...
[17:29:46.138] - Validating connection of MultisessionFuture
[17:29:46.139] - received message: FutureResult
[17:29:46.139] - Received FutureResult
[17:29:46.139] - Erased future from FutureRegistry
[17:29:46.139] result() for ClusterFuture ...
[17:29:46.139] - result already collected: FutureResult
[17:29:46.140] result() for ClusterFuture ... done
[17:29:46.140] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.140] resolve() on list ...
[17:29:46.140]  recursive: 0
[17:29:46.141]  length: 4
[17:29:46.141] 
[17:29:46.141] Future #1
[17:29:46.141] result() for ClusterFuture ...
[17:29:46.141] - result already collected: FutureResult
[17:29:46.142] result() for ClusterFuture ... done
[17:29:46.142] result() for ClusterFuture ...
[17:29:46.142] - result already collected: FutureResult
[17:29:46.142] result() for ClusterFuture ... done
[17:29:46.142] signalConditionsASAP(MultisessionFuture, pos=1) ...
[17:29:46.142] - nx: 4
[17:29:46.143] - relay: TRUE
[17:29:46.143] - stdout: TRUE
[17:29:46.143] - signal: TRUE
[17:29:46.143] - resignal: FALSE
[17:29:46.143] - force: TRUE
[17:29:46.143] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:46.144] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:46.144]  - until=1
[17:29:46.144]  - relaying element #1
[17:29:46.145] result() for ClusterFuture ...
[17:29:46.145] - result already collected: FutureResult
[17:29:46.145] result() for ClusterFuture ... done
[17:29:46.145] result() for ClusterFuture ...
[17:29:46.146] - result already collected: FutureResult
[17:29:46.146] result() for ClusterFuture ... done
[17:29:46.146] result() for ClusterFuture ...
[17:29:46.146] - result already collected: FutureResult
[17:29:46.147] result() for ClusterFuture ... done
[17:29:46.147] result() for ClusterFuture ...
[17:29:46.147] - result already collected: FutureResult
[17:29:46.147] result() for ClusterFuture ... done
[17:29:46.148] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:46.148] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:46.148] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[17:29:46.148]  length: 3 (resolved future 1)
[17:29:46.149] Future #2
[17:29:46.149] result() for ClusterFuture ...
[17:29:46.149] - result already collected: FutureResult
[17:29:46.149] result() for ClusterFuture ... done
[17:29:46.150] result() for ClusterFuture ...
[17:29:46.150] - result already collected: FutureResult
[17:29:46.150] result() for ClusterFuture ... done
[17:29:46.150] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:29:46.151] - nx: 4
[17:29:46.151] - relay: TRUE
[17:29:46.151] - stdout: TRUE
[17:29:46.151] - signal: TRUE
[17:29:46.151] - resignal: FALSE
[17:29:46.152] - force: TRUE
[17:29:46.152] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:46.152] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:46.152]  - until=2
[17:29:46.153]  - relaying element #2
[17:29:46.153] result() for ClusterFuture ...
[17:29:46.153] - result already collected: FutureResult
[17:29:46.153] result() for ClusterFuture ... done
[17:29:46.154] result() for ClusterFuture ...
[17:29:46.154] - result already collected: FutureResult
[17:29:46.154] result() for ClusterFuture ... done
[17:29:46.154] result() for ClusterFuture ...
[17:29:46.155] - result already collected: FutureResult
[17:29:46.155] result() for ClusterFuture ... done
[17:29:46.155] result() for ClusterFuture ...
[17:29:46.155] - result already collected: FutureResult
[17:29:46.156] result() for ClusterFuture ... done
[17:29:46.156] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:46.156] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:46.156] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:29:46.157]  length: 2 (resolved future 2)
[17:29:46.157] Future #3
[17:29:46.157] result() for ClusterFuture ...
[17:29:46.157] - result already collected: FutureResult
[17:29:46.158] result() for ClusterFuture ... done
[17:29:46.158] result() for ClusterFuture ...
[17:29:46.158] - result already collected: FutureResult
[17:29:46.158] result() for ClusterFuture ... done
[17:29:46.159] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:29:46.159] - nx: 4
[17:29:46.159] - relay: TRUE
[17:29:46.159] - stdout: TRUE
[17:29:46.159] - signal: TRUE
[17:29:46.160] - resignal: FALSE
[17:29:46.160] - force: TRUE
[17:29:46.160] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:46.160] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:46.161]  - until=3
[17:29:46.161]  - relaying element #3
[17:29:46.161] result() for ClusterFuture ...
[17:29:46.161] - result already collected: FutureResult
[17:29:46.162] result() for ClusterFuture ... done
[17:29:46.162] result() for ClusterFuture ...
[17:29:46.162] - result already collected: FutureResult
[17:29:46.162] result() for ClusterFuture ... done
[17:29:46.163] result() for ClusterFuture ...
[17:29:46.163] - result already collected: FutureResult
[17:29:46.163] result() for ClusterFuture ... done
[17:29:46.163] result() for ClusterFuture ...
[17:29:46.164] - result already collected: FutureResult
[17:29:46.164] result() for ClusterFuture ... done
[17:29:46.164] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:46.164] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:46.164] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:29:46.165]  length: 1 (resolved future 3)
[17:29:46.165] Future #4
[17:29:46.165] result() for ClusterFuture ...
[17:29:46.166] - result already collected: FutureResult
[17:29:46.166] result() for ClusterFuture ... done
[17:29:46.166] result() for ClusterFuture ...
[17:29:46.166] - result already collected: FutureResult
[17:29:46.167] result() for ClusterFuture ... done
[17:29:46.167] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:29:46.167] - nx: 4
[17:29:46.167] - relay: TRUE
[17:29:46.168] - stdout: TRUE
[17:29:46.168] - signal: TRUE
[17:29:46.168] - resignal: FALSE
[17:29:46.168] - force: TRUE
[17:29:46.168] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:46.169] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:46.169]  - until=4
[17:29:46.169]  - relaying element #4
[17:29:46.169] result() for ClusterFuture ...
[17:29:46.170] - result already collected: FutureResult
[17:29:46.170] result() for ClusterFuture ... done
[17:29:46.170] result() for ClusterFuture ...
[17:29:46.170] - result already collected: FutureResult
[17:29:46.171] result() for ClusterFuture ... done
[17:29:46.171] result() for ClusterFuture ...
[17:29:46.171] - result already collected: FutureResult
[17:29:46.171] result() for ClusterFuture ... done
[17:29:46.172] result() for ClusterFuture ...
[17:29:46.172] - result already collected: FutureResult
[17:29:46.172] result() for ClusterFuture ... done
[17:29:46.172] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:46.173] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:46.173] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:29:46.173]  length: 0 (resolved future 4)
[17:29:46.174] Relaying remaining futures
[17:29:46.174] signalConditionsASAP(NULL, pos=0) ...
[17:29:46.174] - nx: 4
[17:29:46.174] - relay: TRUE
[17:29:46.175] - stdout: TRUE
[17:29:46.175] - signal: TRUE
[17:29:46.175] - resignal: FALSE
[17:29:46.175] - force: TRUE
[17:29:46.176] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:46.176] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:29:46.176] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:46.177] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:46.177] signalConditionsASAP(NULL, pos=0) ... done
[17:29:46.177] resolve() on list ... DONE
[17:29:46.177] result() for ClusterFuture ...
[17:29:46.178] - result already collected: FutureResult
[17:29:46.178] result() for ClusterFuture ... done
[17:29:46.178] result() for ClusterFuture ...
[17:29:46.178] - result already collected: FutureResult
[17:29:46.178] result() for ClusterFuture ... done
[17:29:46.179] result() for ClusterFuture ...
[17:29:46.179] - result already collected: FutureResult
[17:29:46.179] result() for ClusterFuture ... done
[17:29:46.179] result() for ClusterFuture ...
[17:29:46.180] - result already collected: FutureResult
[17:29:46.180] result() for ClusterFuture ... done
[17:29:46.180] result() for ClusterFuture ...
[17:29:46.180] - result already collected: FutureResult
[17:29:46.181] result() for ClusterFuture ... done
[17:29:46.181] result() for ClusterFuture ...
[17:29:46.181] - result already collected: FutureResult
[17:29:46.181] result() for ClusterFuture ... done
[17:29:46.182] result() for ClusterFuture ...
[17:29:46.182] - result already collected: FutureResult
[17:29:46.182] result() for ClusterFuture ... done
[17:29:46.182] result() for ClusterFuture ...
[17:29:46.182] - result already collected: FutureResult
[17:29:46.183] result() for ClusterFuture ... done
[[1]]
[1] 3

[[2]]
[1] 0

[[3]]
[1] 1

[[4]]
[1] 2

[17:29:46.183] getGlobalsAndPackages() ...
[17:29:46.184] Searching for globals...
[17:29:46.189] - globals found: [3] '{', 'sample', 'x'
[17:29:46.190] Searching for globals ... DONE
[17:29:46.190] Resolving globals: FALSE
[17:29:46.191] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:46.191] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:46.192] - globals: [1] 'x'
[17:29:46.192] 
[17:29:46.192] getGlobalsAndPackages() ... DONE
[17:29:46.193] run() for 'Future' ...
[17:29:46.193] - state: 'created'
[17:29:46.193] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:46.210] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.211] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:46.211]   - Field: 'node'
[17:29:46.212]   - Field: 'label'
[17:29:46.212]   - Field: 'local'
[17:29:46.212]   - Field: 'owner'
[17:29:46.212]   - Field: 'envir'
[17:29:46.213]   - Field: 'workers'
[17:29:46.213]   - Field: 'packages'
[17:29:46.213]   - Field: 'gc'
[17:29:46.214]   - Field: 'conditions'
[17:29:46.214]   - Field: 'persistent'
[17:29:46.214]   - Field: 'expr'
[17:29:46.214]   - Field: 'uuid'
[17:29:46.215]   - Field: 'seed'
[17:29:46.215]   - Field: 'version'
[17:29:46.215]   - Field: 'result'
[17:29:46.216]   - Field: 'asynchronous'
[17:29:46.216]   - Field: 'calls'
[17:29:46.216]   - Field: 'globals'
[17:29:46.217]   - Field: 'stdout'
[17:29:46.217]   - Field: 'earlySignal'
[17:29:46.217]   - Field: 'lazy'
[17:29:46.217]   - Field: 'state'
[17:29:46.218] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:46.218] - Launch lazy future ...
[17:29:46.219] Packages needed by the future expression (n = 0): <none>
[17:29:46.219] Packages needed by future strategies (n = 0): <none>
[17:29:46.220] {
[17:29:46.220]     {
[17:29:46.220]         {
[17:29:46.220]             ...future.startTime <- base::Sys.time()
[17:29:46.220]             {
[17:29:46.220]                 {
[17:29:46.220]                   {
[17:29:46.220]                     {
[17:29:46.220]                       base::local({
[17:29:46.220]                         has_future <- base::requireNamespace("future", 
[17:29:46.220]                           quietly = TRUE)
[17:29:46.220]                         if (has_future) {
[17:29:46.220]                           ns <- base::getNamespace("future")
[17:29:46.220]                           version <- ns[[".package"]][["version"]]
[17:29:46.220]                           if (is.null(version)) 
[17:29:46.220]                             version <- utils::packageVersion("future")
[17:29:46.220]                         }
[17:29:46.220]                         else {
[17:29:46.220]                           version <- NULL
[17:29:46.220]                         }
[17:29:46.220]                         if (!has_future || version < "1.8.0") {
[17:29:46.220]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:46.220]                             "", base::R.version$version.string), 
[17:29:46.220]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:46.220]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:46.220]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:46.220]                               "release", "version")], collapse = " "), 
[17:29:46.220]                             hostname = base::Sys.info()[["nodename"]])
[17:29:46.220]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:46.220]                             info)
[17:29:46.220]                           info <- base::paste(info, collapse = "; ")
[17:29:46.220]                           if (!has_future) {
[17:29:46.220]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:46.220]                               info)
[17:29:46.220]                           }
[17:29:46.220]                           else {
[17:29:46.220]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:46.220]                               info, version)
[17:29:46.220]                           }
[17:29:46.220]                           base::stop(msg)
[17:29:46.220]                         }
[17:29:46.220]                       })
[17:29:46.220]                     }
[17:29:46.220]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:46.220]                     base::options(mc.cores = 1L)
[17:29:46.220]                   }
[17:29:46.220]                   ...future.strategy.old <- future::plan("list")
[17:29:46.220]                   options(future.plan = NULL)
[17:29:46.220]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.220]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:46.220]                 }
[17:29:46.220]                 ...future.workdir <- getwd()
[17:29:46.220]             }
[17:29:46.220]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:46.220]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:46.220]         }
[17:29:46.220]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:46.220]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:46.220]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:46.220]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:46.220]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:46.220]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:46.220]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:46.220]             base::names(...future.oldOptions))
[17:29:46.220]     }
[17:29:46.220]     if (FALSE) {
[17:29:46.220]     }
[17:29:46.220]     else {
[17:29:46.220]         if (TRUE) {
[17:29:46.220]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:46.220]                 open = "w")
[17:29:46.220]         }
[17:29:46.220]         else {
[17:29:46.220]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:46.220]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:46.220]         }
[17:29:46.220]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:46.220]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:46.220]             base::sink(type = "output", split = FALSE)
[17:29:46.220]             base::close(...future.stdout)
[17:29:46.220]         }, add = TRUE)
[17:29:46.220]     }
[17:29:46.220]     ...future.frame <- base::sys.nframe()
[17:29:46.220]     ...future.conditions <- base::list()
[17:29:46.220]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:46.220]     if (FALSE) {
[17:29:46.220]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:46.220]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:46.220]     }
[17:29:46.220]     ...future.result <- base::tryCatch({
[17:29:46.220]         base::withCallingHandlers({
[17:29:46.220]             ...future.value <- base::withVisible(base::local({
[17:29:46.220]                 ...future.makeSendCondition <- base::local({
[17:29:46.220]                   sendCondition <- NULL
[17:29:46.220]                   function(frame = 1L) {
[17:29:46.220]                     if (is.function(sendCondition)) 
[17:29:46.220]                       return(sendCondition)
[17:29:46.220]                     ns <- getNamespace("parallel")
[17:29:46.220]                     if (exists("sendData", mode = "function", 
[17:29:46.220]                       envir = ns)) {
[17:29:46.220]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:46.220]                         envir = ns)
[17:29:46.220]                       envir <- sys.frame(frame)
[17:29:46.220]                       master <- NULL
[17:29:46.220]                       while (!identical(envir, .GlobalEnv) && 
[17:29:46.220]                         !identical(envir, emptyenv())) {
[17:29:46.220]                         if (exists("master", mode = "list", envir = envir, 
[17:29:46.220]                           inherits = FALSE)) {
[17:29:46.220]                           master <- get("master", mode = "list", 
[17:29:46.220]                             envir = envir, inherits = FALSE)
[17:29:46.220]                           if (inherits(master, c("SOCKnode", 
[17:29:46.220]                             "SOCK0node"))) {
[17:29:46.220]                             sendCondition <<- function(cond) {
[17:29:46.220]                               data <- list(type = "VALUE", value = cond, 
[17:29:46.220]                                 success = TRUE)
[17:29:46.220]                               parallel_sendData(master, data)
[17:29:46.220]                             }
[17:29:46.220]                             return(sendCondition)
[17:29:46.220]                           }
[17:29:46.220]                         }
[17:29:46.220]                         frame <- frame + 1L
[17:29:46.220]                         envir <- sys.frame(frame)
[17:29:46.220]                       }
[17:29:46.220]                     }
[17:29:46.220]                     sendCondition <<- function(cond) NULL
[17:29:46.220]                   }
[17:29:46.220]                 })
[17:29:46.220]                 withCallingHandlers({
[17:29:46.220]                   {
[17:29:46.220]                     sample(x, size = 1L)
[17:29:46.220]                   }
[17:29:46.220]                 }, immediateCondition = function(cond) {
[17:29:46.220]                   sendCondition <- ...future.makeSendCondition()
[17:29:46.220]                   sendCondition(cond)
[17:29:46.220]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.220]                   {
[17:29:46.220]                     inherits <- base::inherits
[17:29:46.220]                     invokeRestart <- base::invokeRestart
[17:29:46.220]                     is.null <- base::is.null
[17:29:46.220]                     muffled <- FALSE
[17:29:46.220]                     if (inherits(cond, "message")) {
[17:29:46.220]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:46.220]                       if (muffled) 
[17:29:46.220]                         invokeRestart("muffleMessage")
[17:29:46.220]                     }
[17:29:46.220]                     else if (inherits(cond, "warning")) {
[17:29:46.220]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:46.220]                       if (muffled) 
[17:29:46.220]                         invokeRestart("muffleWarning")
[17:29:46.220]                     }
[17:29:46.220]                     else if (inherits(cond, "condition")) {
[17:29:46.220]                       if (!is.null(pattern)) {
[17:29:46.220]                         computeRestarts <- base::computeRestarts
[17:29:46.220]                         grepl <- base::grepl
[17:29:46.220]                         restarts <- computeRestarts(cond)
[17:29:46.220]                         for (restart in restarts) {
[17:29:46.220]                           name <- restart$name
[17:29:46.220]                           if (is.null(name)) 
[17:29:46.220]                             next
[17:29:46.220]                           if (!grepl(pattern, name)) 
[17:29:46.220]                             next
[17:29:46.220]                           invokeRestart(restart)
[17:29:46.220]                           muffled <- TRUE
[17:29:46.220]                           break
[17:29:46.220]                         }
[17:29:46.220]                       }
[17:29:46.220]                     }
[17:29:46.220]                     invisible(muffled)
[17:29:46.220]                   }
[17:29:46.220]                   muffleCondition(cond)
[17:29:46.220]                 })
[17:29:46.220]             }))
[17:29:46.220]             future::FutureResult(value = ...future.value$value, 
[17:29:46.220]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.220]                   ...future.rng), globalenv = if (FALSE) 
[17:29:46.220]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:46.220]                     ...future.globalenv.names))
[17:29:46.220]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:46.220]         }, condition = base::local({
[17:29:46.220]             c <- base::c
[17:29:46.220]             inherits <- base::inherits
[17:29:46.220]             invokeRestart <- base::invokeRestart
[17:29:46.220]             length <- base::length
[17:29:46.220]             list <- base::list
[17:29:46.220]             seq.int <- base::seq.int
[17:29:46.220]             signalCondition <- base::signalCondition
[17:29:46.220]             sys.calls <- base::sys.calls
[17:29:46.220]             `[[` <- base::`[[`
[17:29:46.220]             `+` <- base::`+`
[17:29:46.220]             `<<-` <- base::`<<-`
[17:29:46.220]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:46.220]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:46.220]                   3L)]
[17:29:46.220]             }
[17:29:46.220]             function(cond) {
[17:29:46.220]                 is_error <- inherits(cond, "error")
[17:29:46.220]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:46.220]                   NULL)
[17:29:46.220]                 if (is_error) {
[17:29:46.220]                   sessionInformation <- function() {
[17:29:46.220]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:46.220]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:46.220]                       search = base::search(), system = base::Sys.info())
[17:29:46.220]                   }
[17:29:46.220]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.220]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:46.220]                     cond$call), session = sessionInformation(), 
[17:29:46.220]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:46.220]                   signalCondition(cond)
[17:29:46.220]                 }
[17:29:46.220]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:46.220]                 "immediateCondition"))) {
[17:29:46.220]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:46.220]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.220]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:46.220]                   if (TRUE && !signal) {
[17:29:46.220]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.220]                     {
[17:29:46.220]                       inherits <- base::inherits
[17:29:46.220]                       invokeRestart <- base::invokeRestart
[17:29:46.220]                       is.null <- base::is.null
[17:29:46.220]                       muffled <- FALSE
[17:29:46.220]                       if (inherits(cond, "message")) {
[17:29:46.220]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.220]                         if (muffled) 
[17:29:46.220]                           invokeRestart("muffleMessage")
[17:29:46.220]                       }
[17:29:46.220]                       else if (inherits(cond, "warning")) {
[17:29:46.220]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.220]                         if (muffled) 
[17:29:46.220]                           invokeRestart("muffleWarning")
[17:29:46.220]                       }
[17:29:46.220]                       else if (inherits(cond, "condition")) {
[17:29:46.220]                         if (!is.null(pattern)) {
[17:29:46.220]                           computeRestarts <- base::computeRestarts
[17:29:46.220]                           grepl <- base::grepl
[17:29:46.220]                           restarts <- computeRestarts(cond)
[17:29:46.220]                           for (restart in restarts) {
[17:29:46.220]                             name <- restart$name
[17:29:46.220]                             if (is.null(name)) 
[17:29:46.220]                               next
[17:29:46.220]                             if (!grepl(pattern, name)) 
[17:29:46.220]                               next
[17:29:46.220]                             invokeRestart(restart)
[17:29:46.220]                             muffled <- TRUE
[17:29:46.220]                             break
[17:29:46.220]                           }
[17:29:46.220]                         }
[17:29:46.220]                       }
[17:29:46.220]                       invisible(muffled)
[17:29:46.220]                     }
[17:29:46.220]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.220]                   }
[17:29:46.220]                 }
[17:29:46.220]                 else {
[17:29:46.220]                   if (TRUE) {
[17:29:46.220]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.220]                     {
[17:29:46.220]                       inherits <- base::inherits
[17:29:46.220]                       invokeRestart <- base::invokeRestart
[17:29:46.220]                       is.null <- base::is.null
[17:29:46.220]                       muffled <- FALSE
[17:29:46.220]                       if (inherits(cond, "message")) {
[17:29:46.220]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.220]                         if (muffled) 
[17:29:46.220]                           invokeRestart("muffleMessage")
[17:29:46.220]                       }
[17:29:46.220]                       else if (inherits(cond, "warning")) {
[17:29:46.220]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.220]                         if (muffled) 
[17:29:46.220]                           invokeRestart("muffleWarning")
[17:29:46.220]                       }
[17:29:46.220]                       else if (inherits(cond, "condition")) {
[17:29:46.220]                         if (!is.null(pattern)) {
[17:29:46.220]                           computeRestarts <- base::computeRestarts
[17:29:46.220]                           grepl <- base::grepl
[17:29:46.220]                           restarts <- computeRestarts(cond)
[17:29:46.220]                           for (restart in restarts) {
[17:29:46.220]                             name <- restart$name
[17:29:46.220]                             if (is.null(name)) 
[17:29:46.220]                               next
[17:29:46.220]                             if (!grepl(pattern, name)) 
[17:29:46.220]                               next
[17:29:46.220]                             invokeRestart(restart)
[17:29:46.220]                             muffled <- TRUE
[17:29:46.220]                             break
[17:29:46.220]                           }
[17:29:46.220]                         }
[17:29:46.220]                       }
[17:29:46.220]                       invisible(muffled)
[17:29:46.220]                     }
[17:29:46.220]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.220]                   }
[17:29:46.220]                 }
[17:29:46.220]             }
[17:29:46.220]         }))
[17:29:46.220]     }, error = function(ex) {
[17:29:46.220]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:46.220]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.220]                 ...future.rng), started = ...future.startTime, 
[17:29:46.220]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:46.220]             version = "1.8"), class = "FutureResult")
[17:29:46.220]     }, finally = {
[17:29:46.220]         if (!identical(...future.workdir, getwd())) 
[17:29:46.220]             setwd(...future.workdir)
[17:29:46.220]         {
[17:29:46.220]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:46.220]                 ...future.oldOptions$nwarnings <- NULL
[17:29:46.220]             }
[17:29:46.220]             base::options(...future.oldOptions)
[17:29:46.220]             if (.Platform$OS.type == "windows") {
[17:29:46.220]                 old_names <- names(...future.oldEnvVars)
[17:29:46.220]                 envs <- base::Sys.getenv()
[17:29:46.220]                 names <- names(envs)
[17:29:46.220]                 common <- intersect(names, old_names)
[17:29:46.220]                 added <- setdiff(names, old_names)
[17:29:46.220]                 removed <- setdiff(old_names, names)
[17:29:46.220]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:46.220]                   envs[common]]
[17:29:46.220]                 NAMES <- toupper(changed)
[17:29:46.220]                 args <- list()
[17:29:46.220]                 for (kk in seq_along(NAMES)) {
[17:29:46.220]                   name <- changed[[kk]]
[17:29:46.220]                   NAME <- NAMES[[kk]]
[17:29:46.220]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.220]                     next
[17:29:46.220]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.220]                 }
[17:29:46.220]                 NAMES <- toupper(added)
[17:29:46.220]                 for (kk in seq_along(NAMES)) {
[17:29:46.220]                   name <- added[[kk]]
[17:29:46.220]                   NAME <- NAMES[[kk]]
[17:29:46.220]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.220]                     next
[17:29:46.220]                   args[[name]] <- ""
[17:29:46.220]                 }
[17:29:46.220]                 NAMES <- toupper(removed)
[17:29:46.220]                 for (kk in seq_along(NAMES)) {
[17:29:46.220]                   name <- removed[[kk]]
[17:29:46.220]                   NAME <- NAMES[[kk]]
[17:29:46.220]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.220]                     next
[17:29:46.220]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.220]                 }
[17:29:46.220]                 if (length(args) > 0) 
[17:29:46.220]                   base::do.call(base::Sys.setenv, args = args)
[17:29:46.220]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:46.220]             }
[17:29:46.220]             else {
[17:29:46.220]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:46.220]             }
[17:29:46.220]             {
[17:29:46.220]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:46.220]                   0L) {
[17:29:46.220]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:46.220]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:46.220]                   base::options(opts)
[17:29:46.220]                 }
[17:29:46.220]                 {
[17:29:46.220]                   {
[17:29:46.220]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:46.220]                     NULL
[17:29:46.220]                   }
[17:29:46.220]                   options(future.plan = NULL)
[17:29:46.220]                   if (is.na(NA_character_)) 
[17:29:46.220]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.220]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:46.220]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:46.220]                     .init = FALSE)
[17:29:46.220]                 }
[17:29:46.220]             }
[17:29:46.220]         }
[17:29:46.220]     })
[17:29:46.220]     if (TRUE) {
[17:29:46.220]         base::sink(type = "output", split = FALSE)
[17:29:46.220]         if (TRUE) {
[17:29:46.220]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:46.220]         }
[17:29:46.220]         else {
[17:29:46.220]             ...future.result["stdout"] <- base::list(NULL)
[17:29:46.220]         }
[17:29:46.220]         base::close(...future.stdout)
[17:29:46.220]         ...future.stdout <- NULL
[17:29:46.220]     }
[17:29:46.220]     ...future.result$conditions <- ...future.conditions
[17:29:46.220]     ...future.result$finished <- base::Sys.time()
[17:29:46.220]     ...future.result
[17:29:46.220] }
[17:29:46.227] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:46.228] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:46.228] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:46.229] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:46.229] MultisessionFuture started
[17:29:46.230] - Launch lazy future ... done
[17:29:46.230] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_1-218749'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001add599c1b8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:29:46.254] receiveMessageFromWorker() for ClusterFuture ...
[17:29:46.255] - Validating connection of MultisessionFuture
[17:29:46.255] - received message: FutureResult
[17:29:46.255] - Received FutureResult
[17:29:46.256] - Erased future from FutureRegistry
[17:29:46.256] result() for ClusterFuture ...
[17:29:46.256] - result already collected: FutureResult
[17:29:46.256] result() for ClusterFuture ... done
[17:29:46.256] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.257] getGlobalsAndPackages() ...
[17:29:46.257] Searching for globals...
[17:29:46.259] - globals found: [3] '{', 'sample', 'x'
[17:29:46.259] Searching for globals ... DONE
[17:29:46.259] Resolving globals: FALSE
[17:29:46.260] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:46.261] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:46.261] - globals: [1] 'x'
[17:29:46.261] 
[17:29:46.262] getGlobalsAndPackages() ... DONE
[17:29:46.262] run() for 'Future' ...
[17:29:46.263] - state: 'created'
[17:29:46.263] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:46.281] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.282] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:46.282]   - Field: 'node'
[17:29:46.282]   - Field: 'label'
[17:29:46.283]   - Field: 'local'
[17:29:46.283]   - Field: 'owner'
[17:29:46.283]   - Field: 'envir'
[17:29:46.284]   - Field: 'workers'
[17:29:46.284]   - Field: 'packages'
[17:29:46.284]   - Field: 'gc'
[17:29:46.285]   - Field: 'conditions'
[17:29:46.285]   - Field: 'persistent'
[17:29:46.285]   - Field: 'expr'
[17:29:46.285]   - Field: 'uuid'
[17:29:46.286]   - Field: 'seed'
[17:29:46.286]   - Field: 'version'
[17:29:46.286]   - Field: 'result'
[17:29:46.287]   - Field: 'asynchronous'
[17:29:46.287]   - Field: 'calls'
[17:29:46.287]   - Field: 'globals'
[17:29:46.287]   - Field: 'stdout'
[17:29:46.288]   - Field: 'earlySignal'
[17:29:46.288]   - Field: 'lazy'
[17:29:46.288]   - Field: 'state'
[17:29:46.289] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:46.289] - Launch lazy future ...
[17:29:46.290] Packages needed by the future expression (n = 0): <none>
[17:29:46.290] Packages needed by future strategies (n = 0): <none>
[17:29:46.291] {
[17:29:46.291]     {
[17:29:46.291]         {
[17:29:46.291]             ...future.startTime <- base::Sys.time()
[17:29:46.291]             {
[17:29:46.291]                 {
[17:29:46.291]                   {
[17:29:46.291]                     {
[17:29:46.291]                       base::local({
[17:29:46.291]                         has_future <- base::requireNamespace("future", 
[17:29:46.291]                           quietly = TRUE)
[17:29:46.291]                         if (has_future) {
[17:29:46.291]                           ns <- base::getNamespace("future")
[17:29:46.291]                           version <- ns[[".package"]][["version"]]
[17:29:46.291]                           if (is.null(version)) 
[17:29:46.291]                             version <- utils::packageVersion("future")
[17:29:46.291]                         }
[17:29:46.291]                         else {
[17:29:46.291]                           version <- NULL
[17:29:46.291]                         }
[17:29:46.291]                         if (!has_future || version < "1.8.0") {
[17:29:46.291]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:46.291]                             "", base::R.version$version.string), 
[17:29:46.291]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:46.291]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:46.291]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:46.291]                               "release", "version")], collapse = " "), 
[17:29:46.291]                             hostname = base::Sys.info()[["nodename"]])
[17:29:46.291]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:46.291]                             info)
[17:29:46.291]                           info <- base::paste(info, collapse = "; ")
[17:29:46.291]                           if (!has_future) {
[17:29:46.291]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:46.291]                               info)
[17:29:46.291]                           }
[17:29:46.291]                           else {
[17:29:46.291]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:46.291]                               info, version)
[17:29:46.291]                           }
[17:29:46.291]                           base::stop(msg)
[17:29:46.291]                         }
[17:29:46.291]                       })
[17:29:46.291]                     }
[17:29:46.291]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:46.291]                     base::options(mc.cores = 1L)
[17:29:46.291]                   }
[17:29:46.291]                   ...future.strategy.old <- future::plan("list")
[17:29:46.291]                   options(future.plan = NULL)
[17:29:46.291]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.291]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:46.291]                 }
[17:29:46.291]                 ...future.workdir <- getwd()
[17:29:46.291]             }
[17:29:46.291]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:46.291]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:46.291]         }
[17:29:46.291]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:46.291]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:46.291]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:46.291]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:46.291]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:46.291]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:46.291]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:46.291]             base::names(...future.oldOptions))
[17:29:46.291]     }
[17:29:46.291]     if (FALSE) {
[17:29:46.291]     }
[17:29:46.291]     else {
[17:29:46.291]         if (TRUE) {
[17:29:46.291]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:46.291]                 open = "w")
[17:29:46.291]         }
[17:29:46.291]         else {
[17:29:46.291]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:46.291]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:46.291]         }
[17:29:46.291]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:46.291]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:46.291]             base::sink(type = "output", split = FALSE)
[17:29:46.291]             base::close(...future.stdout)
[17:29:46.291]         }, add = TRUE)
[17:29:46.291]     }
[17:29:46.291]     ...future.frame <- base::sys.nframe()
[17:29:46.291]     ...future.conditions <- base::list()
[17:29:46.291]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:46.291]     if (FALSE) {
[17:29:46.291]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:46.291]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:46.291]     }
[17:29:46.291]     ...future.result <- base::tryCatch({
[17:29:46.291]         base::withCallingHandlers({
[17:29:46.291]             ...future.value <- base::withVisible(base::local({
[17:29:46.291]                 ...future.makeSendCondition <- base::local({
[17:29:46.291]                   sendCondition <- NULL
[17:29:46.291]                   function(frame = 1L) {
[17:29:46.291]                     if (is.function(sendCondition)) 
[17:29:46.291]                       return(sendCondition)
[17:29:46.291]                     ns <- getNamespace("parallel")
[17:29:46.291]                     if (exists("sendData", mode = "function", 
[17:29:46.291]                       envir = ns)) {
[17:29:46.291]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:46.291]                         envir = ns)
[17:29:46.291]                       envir <- sys.frame(frame)
[17:29:46.291]                       master <- NULL
[17:29:46.291]                       while (!identical(envir, .GlobalEnv) && 
[17:29:46.291]                         !identical(envir, emptyenv())) {
[17:29:46.291]                         if (exists("master", mode = "list", envir = envir, 
[17:29:46.291]                           inherits = FALSE)) {
[17:29:46.291]                           master <- get("master", mode = "list", 
[17:29:46.291]                             envir = envir, inherits = FALSE)
[17:29:46.291]                           if (inherits(master, c("SOCKnode", 
[17:29:46.291]                             "SOCK0node"))) {
[17:29:46.291]                             sendCondition <<- function(cond) {
[17:29:46.291]                               data <- list(type = "VALUE", value = cond, 
[17:29:46.291]                                 success = TRUE)
[17:29:46.291]                               parallel_sendData(master, data)
[17:29:46.291]                             }
[17:29:46.291]                             return(sendCondition)
[17:29:46.291]                           }
[17:29:46.291]                         }
[17:29:46.291]                         frame <- frame + 1L
[17:29:46.291]                         envir <- sys.frame(frame)
[17:29:46.291]                       }
[17:29:46.291]                     }
[17:29:46.291]                     sendCondition <<- function(cond) NULL
[17:29:46.291]                   }
[17:29:46.291]                 })
[17:29:46.291]                 withCallingHandlers({
[17:29:46.291]                   {
[17:29:46.291]                     sample(x, size = 1L)
[17:29:46.291]                   }
[17:29:46.291]                 }, immediateCondition = function(cond) {
[17:29:46.291]                   sendCondition <- ...future.makeSendCondition()
[17:29:46.291]                   sendCondition(cond)
[17:29:46.291]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.291]                   {
[17:29:46.291]                     inherits <- base::inherits
[17:29:46.291]                     invokeRestart <- base::invokeRestart
[17:29:46.291]                     is.null <- base::is.null
[17:29:46.291]                     muffled <- FALSE
[17:29:46.291]                     if (inherits(cond, "message")) {
[17:29:46.291]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:46.291]                       if (muffled) 
[17:29:46.291]                         invokeRestart("muffleMessage")
[17:29:46.291]                     }
[17:29:46.291]                     else if (inherits(cond, "warning")) {
[17:29:46.291]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:46.291]                       if (muffled) 
[17:29:46.291]                         invokeRestart("muffleWarning")
[17:29:46.291]                     }
[17:29:46.291]                     else if (inherits(cond, "condition")) {
[17:29:46.291]                       if (!is.null(pattern)) {
[17:29:46.291]                         computeRestarts <- base::computeRestarts
[17:29:46.291]                         grepl <- base::grepl
[17:29:46.291]                         restarts <- computeRestarts(cond)
[17:29:46.291]                         for (restart in restarts) {
[17:29:46.291]                           name <- restart$name
[17:29:46.291]                           if (is.null(name)) 
[17:29:46.291]                             next
[17:29:46.291]                           if (!grepl(pattern, name)) 
[17:29:46.291]                             next
[17:29:46.291]                           invokeRestart(restart)
[17:29:46.291]                           muffled <- TRUE
[17:29:46.291]                           break
[17:29:46.291]                         }
[17:29:46.291]                       }
[17:29:46.291]                     }
[17:29:46.291]                     invisible(muffled)
[17:29:46.291]                   }
[17:29:46.291]                   muffleCondition(cond)
[17:29:46.291]                 })
[17:29:46.291]             }))
[17:29:46.291]             future::FutureResult(value = ...future.value$value, 
[17:29:46.291]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.291]                   ...future.rng), globalenv = if (FALSE) 
[17:29:46.291]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:46.291]                     ...future.globalenv.names))
[17:29:46.291]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:46.291]         }, condition = base::local({
[17:29:46.291]             c <- base::c
[17:29:46.291]             inherits <- base::inherits
[17:29:46.291]             invokeRestart <- base::invokeRestart
[17:29:46.291]             length <- base::length
[17:29:46.291]             list <- base::list
[17:29:46.291]             seq.int <- base::seq.int
[17:29:46.291]             signalCondition <- base::signalCondition
[17:29:46.291]             sys.calls <- base::sys.calls
[17:29:46.291]             `[[` <- base::`[[`
[17:29:46.291]             `+` <- base::`+`
[17:29:46.291]             `<<-` <- base::`<<-`
[17:29:46.291]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:46.291]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:46.291]                   3L)]
[17:29:46.291]             }
[17:29:46.291]             function(cond) {
[17:29:46.291]                 is_error <- inherits(cond, "error")
[17:29:46.291]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:46.291]                   NULL)
[17:29:46.291]                 if (is_error) {
[17:29:46.291]                   sessionInformation <- function() {
[17:29:46.291]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:46.291]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:46.291]                       search = base::search(), system = base::Sys.info())
[17:29:46.291]                   }
[17:29:46.291]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.291]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:46.291]                     cond$call), session = sessionInformation(), 
[17:29:46.291]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:46.291]                   signalCondition(cond)
[17:29:46.291]                 }
[17:29:46.291]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:46.291]                 "immediateCondition"))) {
[17:29:46.291]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:46.291]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.291]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:46.291]                   if (TRUE && !signal) {
[17:29:46.291]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.291]                     {
[17:29:46.291]                       inherits <- base::inherits
[17:29:46.291]                       invokeRestart <- base::invokeRestart
[17:29:46.291]                       is.null <- base::is.null
[17:29:46.291]                       muffled <- FALSE
[17:29:46.291]                       if (inherits(cond, "message")) {
[17:29:46.291]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.291]                         if (muffled) 
[17:29:46.291]                           invokeRestart("muffleMessage")
[17:29:46.291]                       }
[17:29:46.291]                       else if (inherits(cond, "warning")) {
[17:29:46.291]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.291]                         if (muffled) 
[17:29:46.291]                           invokeRestart("muffleWarning")
[17:29:46.291]                       }
[17:29:46.291]                       else if (inherits(cond, "condition")) {
[17:29:46.291]                         if (!is.null(pattern)) {
[17:29:46.291]                           computeRestarts <- base::computeRestarts
[17:29:46.291]                           grepl <- base::grepl
[17:29:46.291]                           restarts <- computeRestarts(cond)
[17:29:46.291]                           for (restart in restarts) {
[17:29:46.291]                             name <- restart$name
[17:29:46.291]                             if (is.null(name)) 
[17:29:46.291]                               next
[17:29:46.291]                             if (!grepl(pattern, name)) 
[17:29:46.291]                               next
[17:29:46.291]                             invokeRestart(restart)
[17:29:46.291]                             muffled <- TRUE
[17:29:46.291]                             break
[17:29:46.291]                           }
[17:29:46.291]                         }
[17:29:46.291]                       }
[17:29:46.291]                       invisible(muffled)
[17:29:46.291]                     }
[17:29:46.291]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.291]                   }
[17:29:46.291]                 }
[17:29:46.291]                 else {
[17:29:46.291]                   if (TRUE) {
[17:29:46.291]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.291]                     {
[17:29:46.291]                       inherits <- base::inherits
[17:29:46.291]                       invokeRestart <- base::invokeRestart
[17:29:46.291]                       is.null <- base::is.null
[17:29:46.291]                       muffled <- FALSE
[17:29:46.291]                       if (inherits(cond, "message")) {
[17:29:46.291]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.291]                         if (muffled) 
[17:29:46.291]                           invokeRestart("muffleMessage")
[17:29:46.291]                       }
[17:29:46.291]                       else if (inherits(cond, "warning")) {
[17:29:46.291]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.291]                         if (muffled) 
[17:29:46.291]                           invokeRestart("muffleWarning")
[17:29:46.291]                       }
[17:29:46.291]                       else if (inherits(cond, "condition")) {
[17:29:46.291]                         if (!is.null(pattern)) {
[17:29:46.291]                           computeRestarts <- base::computeRestarts
[17:29:46.291]                           grepl <- base::grepl
[17:29:46.291]                           restarts <- computeRestarts(cond)
[17:29:46.291]                           for (restart in restarts) {
[17:29:46.291]                             name <- restart$name
[17:29:46.291]                             if (is.null(name)) 
[17:29:46.291]                               next
[17:29:46.291]                             if (!grepl(pattern, name)) 
[17:29:46.291]                               next
[17:29:46.291]                             invokeRestart(restart)
[17:29:46.291]                             muffled <- TRUE
[17:29:46.291]                             break
[17:29:46.291]                           }
[17:29:46.291]                         }
[17:29:46.291]                       }
[17:29:46.291]                       invisible(muffled)
[17:29:46.291]                     }
[17:29:46.291]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.291]                   }
[17:29:46.291]                 }
[17:29:46.291]             }
[17:29:46.291]         }))
[17:29:46.291]     }, error = function(ex) {
[17:29:46.291]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:46.291]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.291]                 ...future.rng), started = ...future.startTime, 
[17:29:46.291]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:46.291]             version = "1.8"), class = "FutureResult")
[17:29:46.291]     }, finally = {
[17:29:46.291]         if (!identical(...future.workdir, getwd())) 
[17:29:46.291]             setwd(...future.workdir)
[17:29:46.291]         {
[17:29:46.291]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:46.291]                 ...future.oldOptions$nwarnings <- NULL
[17:29:46.291]             }
[17:29:46.291]             base::options(...future.oldOptions)
[17:29:46.291]             if (.Platform$OS.type == "windows") {
[17:29:46.291]                 old_names <- names(...future.oldEnvVars)
[17:29:46.291]                 envs <- base::Sys.getenv()
[17:29:46.291]                 names <- names(envs)
[17:29:46.291]                 common <- intersect(names, old_names)
[17:29:46.291]                 added <- setdiff(names, old_names)
[17:29:46.291]                 removed <- setdiff(old_names, names)
[17:29:46.291]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:46.291]                   envs[common]]
[17:29:46.291]                 NAMES <- toupper(changed)
[17:29:46.291]                 args <- list()
[17:29:46.291]                 for (kk in seq_along(NAMES)) {
[17:29:46.291]                   name <- changed[[kk]]
[17:29:46.291]                   NAME <- NAMES[[kk]]
[17:29:46.291]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.291]                     next
[17:29:46.291]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.291]                 }
[17:29:46.291]                 NAMES <- toupper(added)
[17:29:46.291]                 for (kk in seq_along(NAMES)) {
[17:29:46.291]                   name <- added[[kk]]
[17:29:46.291]                   NAME <- NAMES[[kk]]
[17:29:46.291]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.291]                     next
[17:29:46.291]                   args[[name]] <- ""
[17:29:46.291]                 }
[17:29:46.291]                 NAMES <- toupper(removed)
[17:29:46.291]                 for (kk in seq_along(NAMES)) {
[17:29:46.291]                   name <- removed[[kk]]
[17:29:46.291]                   NAME <- NAMES[[kk]]
[17:29:46.291]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.291]                     next
[17:29:46.291]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.291]                 }
[17:29:46.291]                 if (length(args) > 0) 
[17:29:46.291]                   base::do.call(base::Sys.setenv, args = args)
[17:29:46.291]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:46.291]             }
[17:29:46.291]             else {
[17:29:46.291]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:46.291]             }
[17:29:46.291]             {
[17:29:46.291]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:46.291]                   0L) {
[17:29:46.291]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:46.291]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:46.291]                   base::options(opts)
[17:29:46.291]                 }
[17:29:46.291]                 {
[17:29:46.291]                   {
[17:29:46.291]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:46.291]                     NULL
[17:29:46.291]                   }
[17:29:46.291]                   options(future.plan = NULL)
[17:29:46.291]                   if (is.na(NA_character_)) 
[17:29:46.291]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.291]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:46.291]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:46.291]                     .init = FALSE)
[17:29:46.291]                 }
[17:29:46.291]             }
[17:29:46.291]         }
[17:29:46.291]     })
[17:29:46.291]     if (TRUE) {
[17:29:46.291]         base::sink(type = "output", split = FALSE)
[17:29:46.291]         if (TRUE) {
[17:29:46.291]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:46.291]         }
[17:29:46.291]         else {
[17:29:46.291]             ...future.result["stdout"] <- base::list(NULL)
[17:29:46.291]         }
[17:29:46.291]         base::close(...future.stdout)
[17:29:46.291]         ...future.stdout <- NULL
[17:29:46.291]     }
[17:29:46.291]     ...future.result$conditions <- ...future.conditions
[17:29:46.291]     ...future.result$finished <- base::Sys.time()
[17:29:46.291]     ...future.result
[17:29:46.291] }
[17:29:46.299] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:46.299] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:46.299] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:46.300] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:46.301] MultisessionFuture started
[17:29:46.301] - Launch lazy future ... done
[17:29:46.301] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_2-55130'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001add599c1b8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:29:46.327] receiveMessageFromWorker() for ClusterFuture ...
[17:29:46.328] - Validating connection of MultisessionFuture
[17:29:46.328] - received message: FutureResult
[17:29:46.329] - Received FutureResult
[17:29:46.329] - Erased future from FutureRegistry
[17:29:46.329] result() for ClusterFuture ...
[17:29:46.330] - result already collected: FutureResult
[17:29:46.330] result() for ClusterFuture ... done
[17:29:46.330] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.331] getGlobalsAndPackages() ...
[17:29:46.331] Searching for globals...
[17:29:46.333] - globals found: [3] '{', 'sample', 'x'
[17:29:46.334] Searching for globals ... DONE
[17:29:46.334] Resolving globals: FALSE
[17:29:46.335] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:46.336] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:46.336] - globals: [1] 'x'
[17:29:46.337] 
[17:29:46.337] getGlobalsAndPackages() ... DONE
[17:29:46.338] run() for 'Future' ...
[17:29:46.338] - state: 'created'
[17:29:46.338] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:46.355] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.356] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:46.356]   - Field: 'node'
[17:29:46.356]   - Field: 'label'
[17:29:46.356]   - Field: 'local'
[17:29:46.357]   - Field: 'owner'
[17:29:46.357]   - Field: 'envir'
[17:29:46.357]   - Field: 'workers'
[17:29:46.357]   - Field: 'packages'
[17:29:46.357]   - Field: 'gc'
[17:29:46.357]   - Field: 'conditions'
[17:29:46.358]   - Field: 'persistent'
[17:29:46.358]   - Field: 'expr'
[17:29:46.358]   - Field: 'uuid'
[17:29:46.358]   - Field: 'seed'
[17:29:46.358]   - Field: 'version'
[17:29:46.359]   - Field: 'result'
[17:29:46.359]   - Field: 'asynchronous'
[17:29:46.359]   - Field: 'calls'
[17:29:46.359]   - Field: 'globals'
[17:29:46.359]   - Field: 'stdout'
[17:29:46.359]   - Field: 'earlySignal'
[17:29:46.360]   - Field: 'lazy'
[17:29:46.360]   - Field: 'state'
[17:29:46.360] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:46.360] - Launch lazy future ...
[17:29:46.361] Packages needed by the future expression (n = 0): <none>
[17:29:46.361] Packages needed by future strategies (n = 0): <none>
[17:29:46.361] {
[17:29:46.361]     {
[17:29:46.361]         {
[17:29:46.361]             ...future.startTime <- base::Sys.time()
[17:29:46.361]             {
[17:29:46.361]                 {
[17:29:46.361]                   {
[17:29:46.361]                     {
[17:29:46.361]                       base::local({
[17:29:46.361]                         has_future <- base::requireNamespace("future", 
[17:29:46.361]                           quietly = TRUE)
[17:29:46.361]                         if (has_future) {
[17:29:46.361]                           ns <- base::getNamespace("future")
[17:29:46.361]                           version <- ns[[".package"]][["version"]]
[17:29:46.361]                           if (is.null(version)) 
[17:29:46.361]                             version <- utils::packageVersion("future")
[17:29:46.361]                         }
[17:29:46.361]                         else {
[17:29:46.361]                           version <- NULL
[17:29:46.361]                         }
[17:29:46.361]                         if (!has_future || version < "1.8.0") {
[17:29:46.361]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:46.361]                             "", base::R.version$version.string), 
[17:29:46.361]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:46.361]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:46.361]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:46.361]                               "release", "version")], collapse = " "), 
[17:29:46.361]                             hostname = base::Sys.info()[["nodename"]])
[17:29:46.361]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:46.361]                             info)
[17:29:46.361]                           info <- base::paste(info, collapse = "; ")
[17:29:46.361]                           if (!has_future) {
[17:29:46.361]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:46.361]                               info)
[17:29:46.361]                           }
[17:29:46.361]                           else {
[17:29:46.361]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:46.361]                               info, version)
[17:29:46.361]                           }
[17:29:46.361]                           base::stop(msg)
[17:29:46.361]                         }
[17:29:46.361]                       })
[17:29:46.361]                     }
[17:29:46.361]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:46.361]                     base::options(mc.cores = 1L)
[17:29:46.361]                   }
[17:29:46.361]                   ...future.strategy.old <- future::plan("list")
[17:29:46.361]                   options(future.plan = NULL)
[17:29:46.361]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.361]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:46.361]                 }
[17:29:46.361]                 ...future.workdir <- getwd()
[17:29:46.361]             }
[17:29:46.361]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:46.361]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:46.361]         }
[17:29:46.361]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:46.361]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:46.361]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:46.361]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:46.361]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:46.361]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:46.361]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:46.361]             base::names(...future.oldOptions))
[17:29:46.361]     }
[17:29:46.361]     if (FALSE) {
[17:29:46.361]     }
[17:29:46.361]     else {
[17:29:46.361]         if (TRUE) {
[17:29:46.361]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:46.361]                 open = "w")
[17:29:46.361]         }
[17:29:46.361]         else {
[17:29:46.361]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:46.361]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:46.361]         }
[17:29:46.361]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:46.361]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:46.361]             base::sink(type = "output", split = FALSE)
[17:29:46.361]             base::close(...future.stdout)
[17:29:46.361]         }, add = TRUE)
[17:29:46.361]     }
[17:29:46.361]     ...future.frame <- base::sys.nframe()
[17:29:46.361]     ...future.conditions <- base::list()
[17:29:46.361]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:46.361]     if (FALSE) {
[17:29:46.361]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:46.361]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:46.361]     }
[17:29:46.361]     ...future.result <- base::tryCatch({
[17:29:46.361]         base::withCallingHandlers({
[17:29:46.361]             ...future.value <- base::withVisible(base::local({
[17:29:46.361]                 ...future.makeSendCondition <- base::local({
[17:29:46.361]                   sendCondition <- NULL
[17:29:46.361]                   function(frame = 1L) {
[17:29:46.361]                     if (is.function(sendCondition)) 
[17:29:46.361]                       return(sendCondition)
[17:29:46.361]                     ns <- getNamespace("parallel")
[17:29:46.361]                     if (exists("sendData", mode = "function", 
[17:29:46.361]                       envir = ns)) {
[17:29:46.361]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:46.361]                         envir = ns)
[17:29:46.361]                       envir <- sys.frame(frame)
[17:29:46.361]                       master <- NULL
[17:29:46.361]                       while (!identical(envir, .GlobalEnv) && 
[17:29:46.361]                         !identical(envir, emptyenv())) {
[17:29:46.361]                         if (exists("master", mode = "list", envir = envir, 
[17:29:46.361]                           inherits = FALSE)) {
[17:29:46.361]                           master <- get("master", mode = "list", 
[17:29:46.361]                             envir = envir, inherits = FALSE)
[17:29:46.361]                           if (inherits(master, c("SOCKnode", 
[17:29:46.361]                             "SOCK0node"))) {
[17:29:46.361]                             sendCondition <<- function(cond) {
[17:29:46.361]                               data <- list(type = "VALUE", value = cond, 
[17:29:46.361]                                 success = TRUE)
[17:29:46.361]                               parallel_sendData(master, data)
[17:29:46.361]                             }
[17:29:46.361]                             return(sendCondition)
[17:29:46.361]                           }
[17:29:46.361]                         }
[17:29:46.361]                         frame <- frame + 1L
[17:29:46.361]                         envir <- sys.frame(frame)
[17:29:46.361]                       }
[17:29:46.361]                     }
[17:29:46.361]                     sendCondition <<- function(cond) NULL
[17:29:46.361]                   }
[17:29:46.361]                 })
[17:29:46.361]                 withCallingHandlers({
[17:29:46.361]                   {
[17:29:46.361]                     sample(x, size = 1L)
[17:29:46.361]                   }
[17:29:46.361]                 }, immediateCondition = function(cond) {
[17:29:46.361]                   sendCondition <- ...future.makeSendCondition()
[17:29:46.361]                   sendCondition(cond)
[17:29:46.361]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.361]                   {
[17:29:46.361]                     inherits <- base::inherits
[17:29:46.361]                     invokeRestart <- base::invokeRestart
[17:29:46.361]                     is.null <- base::is.null
[17:29:46.361]                     muffled <- FALSE
[17:29:46.361]                     if (inherits(cond, "message")) {
[17:29:46.361]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:46.361]                       if (muffled) 
[17:29:46.361]                         invokeRestart("muffleMessage")
[17:29:46.361]                     }
[17:29:46.361]                     else if (inherits(cond, "warning")) {
[17:29:46.361]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:46.361]                       if (muffled) 
[17:29:46.361]                         invokeRestart("muffleWarning")
[17:29:46.361]                     }
[17:29:46.361]                     else if (inherits(cond, "condition")) {
[17:29:46.361]                       if (!is.null(pattern)) {
[17:29:46.361]                         computeRestarts <- base::computeRestarts
[17:29:46.361]                         grepl <- base::grepl
[17:29:46.361]                         restarts <- computeRestarts(cond)
[17:29:46.361]                         for (restart in restarts) {
[17:29:46.361]                           name <- restart$name
[17:29:46.361]                           if (is.null(name)) 
[17:29:46.361]                             next
[17:29:46.361]                           if (!grepl(pattern, name)) 
[17:29:46.361]                             next
[17:29:46.361]                           invokeRestart(restart)
[17:29:46.361]                           muffled <- TRUE
[17:29:46.361]                           break
[17:29:46.361]                         }
[17:29:46.361]                       }
[17:29:46.361]                     }
[17:29:46.361]                     invisible(muffled)
[17:29:46.361]                   }
[17:29:46.361]                   muffleCondition(cond)
[17:29:46.361]                 })
[17:29:46.361]             }))
[17:29:46.361]             future::FutureResult(value = ...future.value$value, 
[17:29:46.361]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.361]                   ...future.rng), globalenv = if (FALSE) 
[17:29:46.361]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:46.361]                     ...future.globalenv.names))
[17:29:46.361]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:46.361]         }, condition = base::local({
[17:29:46.361]             c <- base::c
[17:29:46.361]             inherits <- base::inherits
[17:29:46.361]             invokeRestart <- base::invokeRestart
[17:29:46.361]             length <- base::length
[17:29:46.361]             list <- base::list
[17:29:46.361]             seq.int <- base::seq.int
[17:29:46.361]             signalCondition <- base::signalCondition
[17:29:46.361]             sys.calls <- base::sys.calls
[17:29:46.361]             `[[` <- base::`[[`
[17:29:46.361]             `+` <- base::`+`
[17:29:46.361]             `<<-` <- base::`<<-`
[17:29:46.361]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:46.361]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:46.361]                   3L)]
[17:29:46.361]             }
[17:29:46.361]             function(cond) {
[17:29:46.361]                 is_error <- inherits(cond, "error")
[17:29:46.361]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:46.361]                   NULL)
[17:29:46.361]                 if (is_error) {
[17:29:46.361]                   sessionInformation <- function() {
[17:29:46.361]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:46.361]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:46.361]                       search = base::search(), system = base::Sys.info())
[17:29:46.361]                   }
[17:29:46.361]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.361]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:46.361]                     cond$call), session = sessionInformation(), 
[17:29:46.361]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:46.361]                   signalCondition(cond)
[17:29:46.361]                 }
[17:29:46.361]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:46.361]                 "immediateCondition"))) {
[17:29:46.361]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:46.361]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.361]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:46.361]                   if (TRUE && !signal) {
[17:29:46.361]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.361]                     {
[17:29:46.361]                       inherits <- base::inherits
[17:29:46.361]                       invokeRestart <- base::invokeRestart
[17:29:46.361]                       is.null <- base::is.null
[17:29:46.361]                       muffled <- FALSE
[17:29:46.361]                       if (inherits(cond, "message")) {
[17:29:46.361]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.361]                         if (muffled) 
[17:29:46.361]                           invokeRestart("muffleMessage")
[17:29:46.361]                       }
[17:29:46.361]                       else if (inherits(cond, "warning")) {
[17:29:46.361]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.361]                         if (muffled) 
[17:29:46.361]                           invokeRestart("muffleWarning")
[17:29:46.361]                       }
[17:29:46.361]                       else if (inherits(cond, "condition")) {
[17:29:46.361]                         if (!is.null(pattern)) {
[17:29:46.361]                           computeRestarts <- base::computeRestarts
[17:29:46.361]                           grepl <- base::grepl
[17:29:46.361]                           restarts <- computeRestarts(cond)
[17:29:46.361]                           for (restart in restarts) {
[17:29:46.361]                             name <- restart$name
[17:29:46.361]                             if (is.null(name)) 
[17:29:46.361]                               next
[17:29:46.361]                             if (!grepl(pattern, name)) 
[17:29:46.361]                               next
[17:29:46.361]                             invokeRestart(restart)
[17:29:46.361]                             muffled <- TRUE
[17:29:46.361]                             break
[17:29:46.361]                           }
[17:29:46.361]                         }
[17:29:46.361]                       }
[17:29:46.361]                       invisible(muffled)
[17:29:46.361]                     }
[17:29:46.361]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.361]                   }
[17:29:46.361]                 }
[17:29:46.361]                 else {
[17:29:46.361]                   if (TRUE) {
[17:29:46.361]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.361]                     {
[17:29:46.361]                       inherits <- base::inherits
[17:29:46.361]                       invokeRestart <- base::invokeRestart
[17:29:46.361]                       is.null <- base::is.null
[17:29:46.361]                       muffled <- FALSE
[17:29:46.361]                       if (inherits(cond, "message")) {
[17:29:46.361]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.361]                         if (muffled) 
[17:29:46.361]                           invokeRestart("muffleMessage")
[17:29:46.361]                       }
[17:29:46.361]                       else if (inherits(cond, "warning")) {
[17:29:46.361]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.361]                         if (muffled) 
[17:29:46.361]                           invokeRestart("muffleWarning")
[17:29:46.361]                       }
[17:29:46.361]                       else if (inherits(cond, "condition")) {
[17:29:46.361]                         if (!is.null(pattern)) {
[17:29:46.361]                           computeRestarts <- base::computeRestarts
[17:29:46.361]                           grepl <- base::grepl
[17:29:46.361]                           restarts <- computeRestarts(cond)
[17:29:46.361]                           for (restart in restarts) {
[17:29:46.361]                             name <- restart$name
[17:29:46.361]                             if (is.null(name)) 
[17:29:46.361]                               next
[17:29:46.361]                             if (!grepl(pattern, name)) 
[17:29:46.361]                               next
[17:29:46.361]                             invokeRestart(restart)
[17:29:46.361]                             muffled <- TRUE
[17:29:46.361]                             break
[17:29:46.361]                           }
[17:29:46.361]                         }
[17:29:46.361]                       }
[17:29:46.361]                       invisible(muffled)
[17:29:46.361]                     }
[17:29:46.361]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.361]                   }
[17:29:46.361]                 }
[17:29:46.361]             }
[17:29:46.361]         }))
[17:29:46.361]     }, error = function(ex) {
[17:29:46.361]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:46.361]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.361]                 ...future.rng), started = ...future.startTime, 
[17:29:46.361]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:46.361]             version = "1.8"), class = "FutureResult")
[17:29:46.361]     }, finally = {
[17:29:46.361]         if (!identical(...future.workdir, getwd())) 
[17:29:46.361]             setwd(...future.workdir)
[17:29:46.361]         {
[17:29:46.361]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:46.361]                 ...future.oldOptions$nwarnings <- NULL
[17:29:46.361]             }
[17:29:46.361]             base::options(...future.oldOptions)
[17:29:46.361]             if (.Platform$OS.type == "windows") {
[17:29:46.361]                 old_names <- names(...future.oldEnvVars)
[17:29:46.361]                 envs <- base::Sys.getenv()
[17:29:46.361]                 names <- names(envs)
[17:29:46.361]                 common <- intersect(names, old_names)
[17:29:46.361]                 added <- setdiff(names, old_names)
[17:29:46.361]                 removed <- setdiff(old_names, names)
[17:29:46.361]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:46.361]                   envs[common]]
[17:29:46.361]                 NAMES <- toupper(changed)
[17:29:46.361]                 args <- list()
[17:29:46.361]                 for (kk in seq_along(NAMES)) {
[17:29:46.361]                   name <- changed[[kk]]
[17:29:46.361]                   NAME <- NAMES[[kk]]
[17:29:46.361]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.361]                     next
[17:29:46.361]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.361]                 }
[17:29:46.361]                 NAMES <- toupper(added)
[17:29:46.361]                 for (kk in seq_along(NAMES)) {
[17:29:46.361]                   name <- added[[kk]]
[17:29:46.361]                   NAME <- NAMES[[kk]]
[17:29:46.361]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.361]                     next
[17:29:46.361]                   args[[name]] <- ""
[17:29:46.361]                 }
[17:29:46.361]                 NAMES <- toupper(removed)
[17:29:46.361]                 for (kk in seq_along(NAMES)) {
[17:29:46.361]                   name <- removed[[kk]]
[17:29:46.361]                   NAME <- NAMES[[kk]]
[17:29:46.361]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.361]                     next
[17:29:46.361]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.361]                 }
[17:29:46.361]                 if (length(args) > 0) 
[17:29:46.361]                   base::do.call(base::Sys.setenv, args = args)
[17:29:46.361]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:46.361]             }
[17:29:46.361]             else {
[17:29:46.361]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:46.361]             }
[17:29:46.361]             {
[17:29:46.361]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:46.361]                   0L) {
[17:29:46.361]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:46.361]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:46.361]                   base::options(opts)
[17:29:46.361]                 }
[17:29:46.361]                 {
[17:29:46.361]                   {
[17:29:46.361]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:46.361]                     NULL
[17:29:46.361]                   }
[17:29:46.361]                   options(future.plan = NULL)
[17:29:46.361]                   if (is.na(NA_character_)) 
[17:29:46.361]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.361]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:46.361]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:46.361]                     .init = FALSE)
[17:29:46.361]                 }
[17:29:46.361]             }
[17:29:46.361]         }
[17:29:46.361]     })
[17:29:46.361]     if (TRUE) {
[17:29:46.361]         base::sink(type = "output", split = FALSE)
[17:29:46.361]         if (TRUE) {
[17:29:46.361]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:46.361]         }
[17:29:46.361]         else {
[17:29:46.361]             ...future.result["stdout"] <- base::list(NULL)
[17:29:46.361]         }
[17:29:46.361]         base::close(...future.stdout)
[17:29:46.361]         ...future.stdout <- NULL
[17:29:46.361]     }
[17:29:46.361]     ...future.result$conditions <- ...future.conditions
[17:29:46.361]     ...future.result$finished <- base::Sys.time()
[17:29:46.361]     ...future.result
[17:29:46.361] }
[17:29:46.368] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:46.368] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:46.369] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:46.369] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:46.370] MultisessionFuture started
[17:29:46.370] - Launch lazy future ... done
[17:29:46.371] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_3-426832'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001add599c1b8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:29:46.396] receiveMessageFromWorker() for ClusterFuture ...
[17:29:46.396] - Validating connection of MultisessionFuture
[17:29:46.397] - received message: FutureResult
[17:29:46.397] - Received FutureResult
[17:29:46.398] - Erased future from FutureRegistry
[17:29:46.398] result() for ClusterFuture ...
[17:29:46.398] - result already collected: FutureResult
[17:29:46.398] result() for ClusterFuture ... done
[17:29:46.399] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.399] getGlobalsAndPackages() ...
[17:29:46.400] Searching for globals...
[17:29:46.402] - globals found: [3] '{', 'sample', 'x'
[17:29:46.402] Searching for globals ... DONE
[17:29:46.402] Resolving globals: FALSE
[17:29:46.403] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:46.404] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:46.404] - globals: [1] 'x'
[17:29:46.405] 
[17:29:46.405] getGlobalsAndPackages() ... DONE
[17:29:46.405] run() for 'Future' ...
[17:29:46.406] - state: 'created'
[17:29:46.406] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:46.426] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.427] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:46.427]   - Field: 'node'
[17:29:46.428]   - Field: 'label'
[17:29:46.428]   - Field: 'local'
[17:29:46.428]   - Field: 'owner'
[17:29:46.429]   - Field: 'envir'
[17:29:46.429]   - Field: 'workers'
[17:29:46.429]   - Field: 'packages'
[17:29:46.430]   - Field: 'gc'
[17:29:46.430]   - Field: 'conditions'
[17:29:46.430]   - Field: 'persistent'
[17:29:46.431]   - Field: 'expr'
[17:29:46.431]   - Field: 'uuid'
[17:29:46.431]   - Field: 'seed'
[17:29:46.431]   - Field: 'version'
[17:29:46.432]   - Field: 'result'
[17:29:46.432]   - Field: 'asynchronous'
[17:29:46.432]   - Field: 'calls'
[17:29:46.433]   - Field: 'globals'
[17:29:46.433]   - Field: 'stdout'
[17:29:46.433]   - Field: 'earlySignal'
[17:29:46.434]   - Field: 'lazy'
[17:29:46.434]   - Field: 'state'
[17:29:46.434] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:46.435] - Launch lazy future ...
[17:29:46.435] Packages needed by the future expression (n = 0): <none>
[17:29:46.436] Packages needed by future strategies (n = 0): <none>
[17:29:46.437] {
[17:29:46.437]     {
[17:29:46.437]         {
[17:29:46.437]             ...future.startTime <- base::Sys.time()
[17:29:46.437]             {
[17:29:46.437]                 {
[17:29:46.437]                   {
[17:29:46.437]                     {
[17:29:46.437]                       base::local({
[17:29:46.437]                         has_future <- base::requireNamespace("future", 
[17:29:46.437]                           quietly = TRUE)
[17:29:46.437]                         if (has_future) {
[17:29:46.437]                           ns <- base::getNamespace("future")
[17:29:46.437]                           version <- ns[[".package"]][["version"]]
[17:29:46.437]                           if (is.null(version)) 
[17:29:46.437]                             version <- utils::packageVersion("future")
[17:29:46.437]                         }
[17:29:46.437]                         else {
[17:29:46.437]                           version <- NULL
[17:29:46.437]                         }
[17:29:46.437]                         if (!has_future || version < "1.8.0") {
[17:29:46.437]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:46.437]                             "", base::R.version$version.string), 
[17:29:46.437]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:46.437]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:46.437]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:46.437]                               "release", "version")], collapse = " "), 
[17:29:46.437]                             hostname = base::Sys.info()[["nodename"]])
[17:29:46.437]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:46.437]                             info)
[17:29:46.437]                           info <- base::paste(info, collapse = "; ")
[17:29:46.437]                           if (!has_future) {
[17:29:46.437]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:46.437]                               info)
[17:29:46.437]                           }
[17:29:46.437]                           else {
[17:29:46.437]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:46.437]                               info, version)
[17:29:46.437]                           }
[17:29:46.437]                           base::stop(msg)
[17:29:46.437]                         }
[17:29:46.437]                       })
[17:29:46.437]                     }
[17:29:46.437]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:46.437]                     base::options(mc.cores = 1L)
[17:29:46.437]                   }
[17:29:46.437]                   ...future.strategy.old <- future::plan("list")
[17:29:46.437]                   options(future.plan = NULL)
[17:29:46.437]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.437]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:46.437]                 }
[17:29:46.437]                 ...future.workdir <- getwd()
[17:29:46.437]             }
[17:29:46.437]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:46.437]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:46.437]         }
[17:29:46.437]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:46.437]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:46.437]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:46.437]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:46.437]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:46.437]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:46.437]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:46.437]             base::names(...future.oldOptions))
[17:29:46.437]     }
[17:29:46.437]     if (FALSE) {
[17:29:46.437]     }
[17:29:46.437]     else {
[17:29:46.437]         if (TRUE) {
[17:29:46.437]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:46.437]                 open = "w")
[17:29:46.437]         }
[17:29:46.437]         else {
[17:29:46.437]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:46.437]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:46.437]         }
[17:29:46.437]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:46.437]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:46.437]             base::sink(type = "output", split = FALSE)
[17:29:46.437]             base::close(...future.stdout)
[17:29:46.437]         }, add = TRUE)
[17:29:46.437]     }
[17:29:46.437]     ...future.frame <- base::sys.nframe()
[17:29:46.437]     ...future.conditions <- base::list()
[17:29:46.437]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:46.437]     if (FALSE) {
[17:29:46.437]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:46.437]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:46.437]     }
[17:29:46.437]     ...future.result <- base::tryCatch({
[17:29:46.437]         base::withCallingHandlers({
[17:29:46.437]             ...future.value <- base::withVisible(base::local({
[17:29:46.437]                 ...future.makeSendCondition <- base::local({
[17:29:46.437]                   sendCondition <- NULL
[17:29:46.437]                   function(frame = 1L) {
[17:29:46.437]                     if (is.function(sendCondition)) 
[17:29:46.437]                       return(sendCondition)
[17:29:46.437]                     ns <- getNamespace("parallel")
[17:29:46.437]                     if (exists("sendData", mode = "function", 
[17:29:46.437]                       envir = ns)) {
[17:29:46.437]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:46.437]                         envir = ns)
[17:29:46.437]                       envir <- sys.frame(frame)
[17:29:46.437]                       master <- NULL
[17:29:46.437]                       while (!identical(envir, .GlobalEnv) && 
[17:29:46.437]                         !identical(envir, emptyenv())) {
[17:29:46.437]                         if (exists("master", mode = "list", envir = envir, 
[17:29:46.437]                           inherits = FALSE)) {
[17:29:46.437]                           master <- get("master", mode = "list", 
[17:29:46.437]                             envir = envir, inherits = FALSE)
[17:29:46.437]                           if (inherits(master, c("SOCKnode", 
[17:29:46.437]                             "SOCK0node"))) {
[17:29:46.437]                             sendCondition <<- function(cond) {
[17:29:46.437]                               data <- list(type = "VALUE", value = cond, 
[17:29:46.437]                                 success = TRUE)
[17:29:46.437]                               parallel_sendData(master, data)
[17:29:46.437]                             }
[17:29:46.437]                             return(sendCondition)
[17:29:46.437]                           }
[17:29:46.437]                         }
[17:29:46.437]                         frame <- frame + 1L
[17:29:46.437]                         envir <- sys.frame(frame)
[17:29:46.437]                       }
[17:29:46.437]                     }
[17:29:46.437]                     sendCondition <<- function(cond) NULL
[17:29:46.437]                   }
[17:29:46.437]                 })
[17:29:46.437]                 withCallingHandlers({
[17:29:46.437]                   {
[17:29:46.437]                     sample(x, size = 1L)
[17:29:46.437]                   }
[17:29:46.437]                 }, immediateCondition = function(cond) {
[17:29:46.437]                   sendCondition <- ...future.makeSendCondition()
[17:29:46.437]                   sendCondition(cond)
[17:29:46.437]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.437]                   {
[17:29:46.437]                     inherits <- base::inherits
[17:29:46.437]                     invokeRestart <- base::invokeRestart
[17:29:46.437]                     is.null <- base::is.null
[17:29:46.437]                     muffled <- FALSE
[17:29:46.437]                     if (inherits(cond, "message")) {
[17:29:46.437]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:46.437]                       if (muffled) 
[17:29:46.437]                         invokeRestart("muffleMessage")
[17:29:46.437]                     }
[17:29:46.437]                     else if (inherits(cond, "warning")) {
[17:29:46.437]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:46.437]                       if (muffled) 
[17:29:46.437]                         invokeRestart("muffleWarning")
[17:29:46.437]                     }
[17:29:46.437]                     else if (inherits(cond, "condition")) {
[17:29:46.437]                       if (!is.null(pattern)) {
[17:29:46.437]                         computeRestarts <- base::computeRestarts
[17:29:46.437]                         grepl <- base::grepl
[17:29:46.437]                         restarts <- computeRestarts(cond)
[17:29:46.437]                         for (restart in restarts) {
[17:29:46.437]                           name <- restart$name
[17:29:46.437]                           if (is.null(name)) 
[17:29:46.437]                             next
[17:29:46.437]                           if (!grepl(pattern, name)) 
[17:29:46.437]                             next
[17:29:46.437]                           invokeRestart(restart)
[17:29:46.437]                           muffled <- TRUE
[17:29:46.437]                           break
[17:29:46.437]                         }
[17:29:46.437]                       }
[17:29:46.437]                     }
[17:29:46.437]                     invisible(muffled)
[17:29:46.437]                   }
[17:29:46.437]                   muffleCondition(cond)
[17:29:46.437]                 })
[17:29:46.437]             }))
[17:29:46.437]             future::FutureResult(value = ...future.value$value, 
[17:29:46.437]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.437]                   ...future.rng), globalenv = if (FALSE) 
[17:29:46.437]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:46.437]                     ...future.globalenv.names))
[17:29:46.437]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:46.437]         }, condition = base::local({
[17:29:46.437]             c <- base::c
[17:29:46.437]             inherits <- base::inherits
[17:29:46.437]             invokeRestart <- base::invokeRestart
[17:29:46.437]             length <- base::length
[17:29:46.437]             list <- base::list
[17:29:46.437]             seq.int <- base::seq.int
[17:29:46.437]             signalCondition <- base::signalCondition
[17:29:46.437]             sys.calls <- base::sys.calls
[17:29:46.437]             `[[` <- base::`[[`
[17:29:46.437]             `+` <- base::`+`
[17:29:46.437]             `<<-` <- base::`<<-`
[17:29:46.437]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:46.437]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:46.437]                   3L)]
[17:29:46.437]             }
[17:29:46.437]             function(cond) {
[17:29:46.437]                 is_error <- inherits(cond, "error")
[17:29:46.437]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:46.437]                   NULL)
[17:29:46.437]                 if (is_error) {
[17:29:46.437]                   sessionInformation <- function() {
[17:29:46.437]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:46.437]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:46.437]                       search = base::search(), system = base::Sys.info())
[17:29:46.437]                   }
[17:29:46.437]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.437]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:46.437]                     cond$call), session = sessionInformation(), 
[17:29:46.437]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:46.437]                   signalCondition(cond)
[17:29:46.437]                 }
[17:29:46.437]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:46.437]                 "immediateCondition"))) {
[17:29:46.437]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:46.437]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.437]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:46.437]                   if (TRUE && !signal) {
[17:29:46.437]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.437]                     {
[17:29:46.437]                       inherits <- base::inherits
[17:29:46.437]                       invokeRestart <- base::invokeRestart
[17:29:46.437]                       is.null <- base::is.null
[17:29:46.437]                       muffled <- FALSE
[17:29:46.437]                       if (inherits(cond, "message")) {
[17:29:46.437]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.437]                         if (muffled) 
[17:29:46.437]                           invokeRestart("muffleMessage")
[17:29:46.437]                       }
[17:29:46.437]                       else if (inherits(cond, "warning")) {
[17:29:46.437]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.437]                         if (muffled) 
[17:29:46.437]                           invokeRestart("muffleWarning")
[17:29:46.437]                       }
[17:29:46.437]                       else if (inherits(cond, "condition")) {
[17:29:46.437]                         if (!is.null(pattern)) {
[17:29:46.437]                           computeRestarts <- base::computeRestarts
[17:29:46.437]                           grepl <- base::grepl
[17:29:46.437]                           restarts <- computeRestarts(cond)
[17:29:46.437]                           for (restart in restarts) {
[17:29:46.437]                             name <- restart$name
[17:29:46.437]                             if (is.null(name)) 
[17:29:46.437]                               next
[17:29:46.437]                             if (!grepl(pattern, name)) 
[17:29:46.437]                               next
[17:29:46.437]                             invokeRestart(restart)
[17:29:46.437]                             muffled <- TRUE
[17:29:46.437]                             break
[17:29:46.437]                           }
[17:29:46.437]                         }
[17:29:46.437]                       }
[17:29:46.437]                       invisible(muffled)
[17:29:46.437]                     }
[17:29:46.437]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.437]                   }
[17:29:46.437]                 }
[17:29:46.437]                 else {
[17:29:46.437]                   if (TRUE) {
[17:29:46.437]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.437]                     {
[17:29:46.437]                       inherits <- base::inherits
[17:29:46.437]                       invokeRestart <- base::invokeRestart
[17:29:46.437]                       is.null <- base::is.null
[17:29:46.437]                       muffled <- FALSE
[17:29:46.437]                       if (inherits(cond, "message")) {
[17:29:46.437]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.437]                         if (muffled) 
[17:29:46.437]                           invokeRestart("muffleMessage")
[17:29:46.437]                       }
[17:29:46.437]                       else if (inherits(cond, "warning")) {
[17:29:46.437]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.437]                         if (muffled) 
[17:29:46.437]                           invokeRestart("muffleWarning")
[17:29:46.437]                       }
[17:29:46.437]                       else if (inherits(cond, "condition")) {
[17:29:46.437]                         if (!is.null(pattern)) {
[17:29:46.437]                           computeRestarts <- base::computeRestarts
[17:29:46.437]                           grepl <- base::grepl
[17:29:46.437]                           restarts <- computeRestarts(cond)
[17:29:46.437]                           for (restart in restarts) {
[17:29:46.437]                             name <- restart$name
[17:29:46.437]                             if (is.null(name)) 
[17:29:46.437]                               next
[17:29:46.437]                             if (!grepl(pattern, name)) 
[17:29:46.437]                               next
[17:29:46.437]                             invokeRestart(restart)
[17:29:46.437]                             muffled <- TRUE
[17:29:46.437]                             break
[17:29:46.437]                           }
[17:29:46.437]                         }
[17:29:46.437]                       }
[17:29:46.437]                       invisible(muffled)
[17:29:46.437]                     }
[17:29:46.437]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.437]                   }
[17:29:46.437]                 }
[17:29:46.437]             }
[17:29:46.437]         }))
[17:29:46.437]     }, error = function(ex) {
[17:29:46.437]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:46.437]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.437]                 ...future.rng), started = ...future.startTime, 
[17:29:46.437]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:46.437]             version = "1.8"), class = "FutureResult")
[17:29:46.437]     }, finally = {
[17:29:46.437]         if (!identical(...future.workdir, getwd())) 
[17:29:46.437]             setwd(...future.workdir)
[17:29:46.437]         {
[17:29:46.437]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:46.437]                 ...future.oldOptions$nwarnings <- NULL
[17:29:46.437]             }
[17:29:46.437]             base::options(...future.oldOptions)
[17:29:46.437]             if (.Platform$OS.type == "windows") {
[17:29:46.437]                 old_names <- names(...future.oldEnvVars)
[17:29:46.437]                 envs <- base::Sys.getenv()
[17:29:46.437]                 names <- names(envs)
[17:29:46.437]                 common <- intersect(names, old_names)
[17:29:46.437]                 added <- setdiff(names, old_names)
[17:29:46.437]                 removed <- setdiff(old_names, names)
[17:29:46.437]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:46.437]                   envs[common]]
[17:29:46.437]                 NAMES <- toupper(changed)
[17:29:46.437]                 args <- list()
[17:29:46.437]                 for (kk in seq_along(NAMES)) {
[17:29:46.437]                   name <- changed[[kk]]
[17:29:46.437]                   NAME <- NAMES[[kk]]
[17:29:46.437]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.437]                     next
[17:29:46.437]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.437]                 }
[17:29:46.437]                 NAMES <- toupper(added)
[17:29:46.437]                 for (kk in seq_along(NAMES)) {
[17:29:46.437]                   name <- added[[kk]]
[17:29:46.437]                   NAME <- NAMES[[kk]]
[17:29:46.437]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.437]                     next
[17:29:46.437]                   args[[name]] <- ""
[17:29:46.437]                 }
[17:29:46.437]                 NAMES <- toupper(removed)
[17:29:46.437]                 for (kk in seq_along(NAMES)) {
[17:29:46.437]                   name <- removed[[kk]]
[17:29:46.437]                   NAME <- NAMES[[kk]]
[17:29:46.437]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.437]                     next
[17:29:46.437]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.437]                 }
[17:29:46.437]                 if (length(args) > 0) 
[17:29:46.437]                   base::do.call(base::Sys.setenv, args = args)
[17:29:46.437]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:46.437]             }
[17:29:46.437]             else {
[17:29:46.437]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:46.437]             }
[17:29:46.437]             {
[17:29:46.437]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:46.437]                   0L) {
[17:29:46.437]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:46.437]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:46.437]                   base::options(opts)
[17:29:46.437]                 }
[17:29:46.437]                 {
[17:29:46.437]                   {
[17:29:46.437]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:46.437]                     NULL
[17:29:46.437]                   }
[17:29:46.437]                   options(future.plan = NULL)
[17:29:46.437]                   if (is.na(NA_character_)) 
[17:29:46.437]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.437]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:46.437]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:46.437]                     .init = FALSE)
[17:29:46.437]                 }
[17:29:46.437]             }
[17:29:46.437]         }
[17:29:46.437]     })
[17:29:46.437]     if (TRUE) {
[17:29:46.437]         base::sink(type = "output", split = FALSE)
[17:29:46.437]         if (TRUE) {
[17:29:46.437]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:46.437]         }
[17:29:46.437]         else {
[17:29:46.437]             ...future.result["stdout"] <- base::list(NULL)
[17:29:46.437]         }
[17:29:46.437]         base::close(...future.stdout)
[17:29:46.437]         ...future.stdout <- NULL
[17:29:46.437]     }
[17:29:46.437]     ...future.result$conditions <- ...future.conditions
[17:29:46.437]     ...future.result$finished <- base::Sys.time()
[17:29:46.437]     ...future.result
[17:29:46.437] }
[17:29:46.445] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:46.446] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:46.446] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:46.447] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:46.448] MultisessionFuture started
[17:29:46.448] - Launch lazy future ... done
[17:29:46.448] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_4-37239'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001add599c1b8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[17:29:46.472] receiveMessageFromWorker() for ClusterFuture ...
[17:29:46.473] - Validating connection of MultisessionFuture
[17:29:46.474] - received message: FutureResult
[17:29:46.474] - Received FutureResult
[17:29:46.474] - Erased future from FutureRegistry
[17:29:46.475] result() for ClusterFuture ...
[17:29:46.475] - result already collected: FutureResult
[17:29:46.475] result() for ClusterFuture ... done
[17:29:46.476] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.476] resolve() on list ...
[17:29:46.476]  recursive: 0
[17:29:46.477]  length: 4
[17:29:46.477] 
[17:29:46.477] Future #1
[17:29:46.478] result() for ClusterFuture ...
[17:29:46.478] - result already collected: FutureResult
[17:29:46.478] result() for ClusterFuture ... done
[17:29:46.479] result() for ClusterFuture ...
[17:29:46.479] - result already collected: FutureResult
[17:29:46.479] result() for ClusterFuture ... done
[17:29:46.480] signalConditionsASAP(MultisessionFuture, pos=1) ...
[17:29:46.480] - nx: 4
[17:29:46.480] - relay: TRUE
[17:29:46.481] - stdout: TRUE
[17:29:46.481] - signal: TRUE
[17:29:46.481] - resignal: FALSE
[17:29:46.482] - force: TRUE
[17:29:46.482] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:46.482] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:46.482]  - until=1
[17:29:46.483]  - relaying element #1
[17:29:46.483] result() for ClusterFuture ...
[17:29:46.483] - result already collected: FutureResult
[17:29:46.484] result() for ClusterFuture ... done
[17:29:46.484] result() for ClusterFuture ...
[17:29:46.484] - result already collected: FutureResult
[17:29:46.485] result() for ClusterFuture ... done
[17:29:46.485] signalConditions() ...
[17:29:46.485]  - include = 'immediateCondition'
[17:29:46.485]  - exclude = 
[17:29:46.486]  - resignal = FALSE
[17:29:46.486]  - Number of conditions: 1
[17:29:46.486] signalConditions() ... done
[17:29:46.487] result() for ClusterFuture ...
[17:29:46.487] - result already collected: FutureResult
[17:29:46.487] result() for ClusterFuture ... done
[17:29:46.488] signalConditions() ...
[17:29:46.488]  - include = 'immediateCondition'
[17:29:46.488]  - exclude = 
[17:29:46.489]  - resignal = FALSE
[17:29:46.489]  - Number of conditions: 1
[17:29:46.489] signalConditions() ... done
[17:29:46.490] result() for ClusterFuture ...
[17:29:46.490] - result already collected: FutureResult
[17:29:46.490] result() for ClusterFuture ... done
[17:29:46.490] signalConditions() ...
[17:29:46.491]  - include = 'condition'
[17:29:46.491]  - exclude = 'immediateCondition'
[17:29:46.491]  - resignal = TRUE
[17:29:46.492]  - Number of conditions: 1
[17:29:46.492]  - Condition #1: 'RngFutureError', 'FutureError', 'error', 'RngFutureCondition', 'FutureCondition', 'condition'
[17:29:46.492] signalConditions() ... done
[17:29:46.493] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:46.493] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:46.493] signalConditionsASAP(MultisessionFuture, pos=1) ... done
<RngFutureError: UNRELIABLE VALUE: Future ('fsample_1-218749') 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: 750411b4-2444-61d8-2377-1f67562d26fe


DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
MultisessionFuture:
Label: 'fsample_1-218749'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001add599c1b8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Conditions captured: [n=1] 'RngFutureError'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'

DEBUG: END TROUBLESHOOTING HELP
[17:29:46.495] getGlobalsAndPackages() ...
[17:29:46.496] Searching for globals...
[17:29:46.498] - globals found: [3] '{', 'sample', 'x'
[17:29:46.498] Searching for globals ... DONE
[17:29:46.498] Resolving globals: FALSE
[17:29:46.499] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:46.500] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:46.500] - globals: [1] 'x'
[17:29:46.501] 
[17:29:46.501] getGlobalsAndPackages() ... DONE
[17:29:46.501] run() for 'Future' ...
[17:29:46.502] - state: 'created'
[17:29:46.502] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:46.522] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.523] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:46.523]   - Field: 'node'
[17:29:46.523]   - Field: 'label'
[17:29:46.524]   - Field: 'local'
[17:29:46.524]   - Field: 'owner'
[17:29:46.524]   - Field: 'envir'
[17:29:46.524]   - Field: 'workers'
[17:29:46.525]   - Field: 'packages'
[17:29:46.525]   - Field: 'gc'
[17:29:46.525]   - Field: 'conditions'
[17:29:46.526]   - Field: 'persistent'
[17:29:46.526]   - Field: 'expr'
[17:29:46.526]   - Field: 'uuid'
[17:29:46.527]   - Field: 'seed'
[17:29:46.527]   - Field: 'version'
[17:29:46.527]   - Field: 'result'
[17:29:46.528]   - Field: 'asynchronous'
[17:29:46.528]   - Field: 'calls'
[17:29:46.528]   - Field: 'globals'
[17:29:46.528]   - Field: 'stdout'
[17:29:46.529]   - Field: 'earlySignal'
[17:29:46.529]   - Field: 'lazy'
[17:29:46.529]   - Field: 'state'
[17:29:46.529] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:46.530] - Launch lazy future ...
[17:29:46.530] Packages needed by the future expression (n = 0): <none>
[17:29:46.531] Packages needed by future strategies (n = 0): <none>
[17:29:46.531] {
[17:29:46.531]     {
[17:29:46.531]         {
[17:29:46.531]             ...future.startTime <- base::Sys.time()
[17:29:46.531]             {
[17:29:46.531]                 {
[17:29:46.531]                   {
[17:29:46.531]                     {
[17:29:46.531]                       base::local({
[17:29:46.531]                         has_future <- base::requireNamespace("future", 
[17:29:46.531]                           quietly = TRUE)
[17:29:46.531]                         if (has_future) {
[17:29:46.531]                           ns <- base::getNamespace("future")
[17:29:46.531]                           version <- ns[[".package"]][["version"]]
[17:29:46.531]                           if (is.null(version)) 
[17:29:46.531]                             version <- utils::packageVersion("future")
[17:29:46.531]                         }
[17:29:46.531]                         else {
[17:29:46.531]                           version <- NULL
[17:29:46.531]                         }
[17:29:46.531]                         if (!has_future || version < "1.8.0") {
[17:29:46.531]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:46.531]                             "", base::R.version$version.string), 
[17:29:46.531]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:46.531]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:46.531]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:46.531]                               "release", "version")], collapse = " "), 
[17:29:46.531]                             hostname = base::Sys.info()[["nodename"]])
[17:29:46.531]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:46.531]                             info)
[17:29:46.531]                           info <- base::paste(info, collapse = "; ")
[17:29:46.531]                           if (!has_future) {
[17:29:46.531]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:46.531]                               info)
[17:29:46.531]                           }
[17:29:46.531]                           else {
[17:29:46.531]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:46.531]                               info, version)
[17:29:46.531]                           }
[17:29:46.531]                           base::stop(msg)
[17:29:46.531]                         }
[17:29:46.531]                       })
[17:29:46.531]                     }
[17:29:46.531]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:46.531]                     base::options(mc.cores = 1L)
[17:29:46.531]                   }
[17:29:46.531]                   ...future.strategy.old <- future::plan("list")
[17:29:46.531]                   options(future.plan = NULL)
[17:29:46.531]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.531]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:46.531]                 }
[17:29:46.531]                 ...future.workdir <- getwd()
[17:29:46.531]             }
[17:29:46.531]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:46.531]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:46.531]         }
[17:29:46.531]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:46.531]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:46.531]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:46.531]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:46.531]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:46.531]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:46.531]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:46.531]             base::names(...future.oldOptions))
[17:29:46.531]     }
[17:29:46.531]     if (FALSE) {
[17:29:46.531]     }
[17:29:46.531]     else {
[17:29:46.531]         if (TRUE) {
[17:29:46.531]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:46.531]                 open = "w")
[17:29:46.531]         }
[17:29:46.531]         else {
[17:29:46.531]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:46.531]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:46.531]         }
[17:29:46.531]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:46.531]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:46.531]             base::sink(type = "output", split = FALSE)
[17:29:46.531]             base::close(...future.stdout)
[17:29:46.531]         }, add = TRUE)
[17:29:46.531]     }
[17:29:46.531]     ...future.frame <- base::sys.nframe()
[17:29:46.531]     ...future.conditions <- base::list()
[17:29:46.531]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:46.531]     if (FALSE) {
[17:29:46.531]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:46.531]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:46.531]     }
[17:29:46.531]     ...future.result <- base::tryCatch({
[17:29:46.531]         base::withCallingHandlers({
[17:29:46.531]             ...future.value <- base::withVisible(base::local({
[17:29:46.531]                 ...future.makeSendCondition <- base::local({
[17:29:46.531]                   sendCondition <- NULL
[17:29:46.531]                   function(frame = 1L) {
[17:29:46.531]                     if (is.function(sendCondition)) 
[17:29:46.531]                       return(sendCondition)
[17:29:46.531]                     ns <- getNamespace("parallel")
[17:29:46.531]                     if (exists("sendData", mode = "function", 
[17:29:46.531]                       envir = ns)) {
[17:29:46.531]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:46.531]                         envir = ns)
[17:29:46.531]                       envir <- sys.frame(frame)
[17:29:46.531]                       master <- NULL
[17:29:46.531]                       while (!identical(envir, .GlobalEnv) && 
[17:29:46.531]                         !identical(envir, emptyenv())) {
[17:29:46.531]                         if (exists("master", mode = "list", envir = envir, 
[17:29:46.531]                           inherits = FALSE)) {
[17:29:46.531]                           master <- get("master", mode = "list", 
[17:29:46.531]                             envir = envir, inherits = FALSE)
[17:29:46.531]                           if (inherits(master, c("SOCKnode", 
[17:29:46.531]                             "SOCK0node"))) {
[17:29:46.531]                             sendCondition <<- function(cond) {
[17:29:46.531]                               data <- list(type = "VALUE", value = cond, 
[17:29:46.531]                                 success = TRUE)
[17:29:46.531]                               parallel_sendData(master, data)
[17:29:46.531]                             }
[17:29:46.531]                             return(sendCondition)
[17:29:46.531]                           }
[17:29:46.531]                         }
[17:29:46.531]                         frame <- frame + 1L
[17:29:46.531]                         envir <- sys.frame(frame)
[17:29:46.531]                       }
[17:29:46.531]                     }
[17:29:46.531]                     sendCondition <<- function(cond) NULL
[17:29:46.531]                   }
[17:29:46.531]                 })
[17:29:46.531]                 withCallingHandlers({
[17:29:46.531]                   {
[17:29:46.531]                     sample(x, size = 1L)
[17:29:46.531]                   }
[17:29:46.531]                 }, immediateCondition = function(cond) {
[17:29:46.531]                   sendCondition <- ...future.makeSendCondition()
[17:29:46.531]                   sendCondition(cond)
[17:29:46.531]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.531]                   {
[17:29:46.531]                     inherits <- base::inherits
[17:29:46.531]                     invokeRestart <- base::invokeRestart
[17:29:46.531]                     is.null <- base::is.null
[17:29:46.531]                     muffled <- FALSE
[17:29:46.531]                     if (inherits(cond, "message")) {
[17:29:46.531]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:46.531]                       if (muffled) 
[17:29:46.531]                         invokeRestart("muffleMessage")
[17:29:46.531]                     }
[17:29:46.531]                     else if (inherits(cond, "warning")) {
[17:29:46.531]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:46.531]                       if (muffled) 
[17:29:46.531]                         invokeRestart("muffleWarning")
[17:29:46.531]                     }
[17:29:46.531]                     else if (inherits(cond, "condition")) {
[17:29:46.531]                       if (!is.null(pattern)) {
[17:29:46.531]                         computeRestarts <- base::computeRestarts
[17:29:46.531]                         grepl <- base::grepl
[17:29:46.531]                         restarts <- computeRestarts(cond)
[17:29:46.531]                         for (restart in restarts) {
[17:29:46.531]                           name <- restart$name
[17:29:46.531]                           if (is.null(name)) 
[17:29:46.531]                             next
[17:29:46.531]                           if (!grepl(pattern, name)) 
[17:29:46.531]                             next
[17:29:46.531]                           invokeRestart(restart)
[17:29:46.531]                           muffled <- TRUE
[17:29:46.531]                           break
[17:29:46.531]                         }
[17:29:46.531]                       }
[17:29:46.531]                     }
[17:29:46.531]                     invisible(muffled)
[17:29:46.531]                   }
[17:29:46.531]                   muffleCondition(cond)
[17:29:46.531]                 })
[17:29:46.531]             }))
[17:29:46.531]             future::FutureResult(value = ...future.value$value, 
[17:29:46.531]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.531]                   ...future.rng), globalenv = if (FALSE) 
[17:29:46.531]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:46.531]                     ...future.globalenv.names))
[17:29:46.531]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:46.531]         }, condition = base::local({
[17:29:46.531]             c <- base::c
[17:29:46.531]             inherits <- base::inherits
[17:29:46.531]             invokeRestart <- base::invokeRestart
[17:29:46.531]             length <- base::length
[17:29:46.531]             list <- base::list
[17:29:46.531]             seq.int <- base::seq.int
[17:29:46.531]             signalCondition <- base::signalCondition
[17:29:46.531]             sys.calls <- base::sys.calls
[17:29:46.531]             `[[` <- base::`[[`
[17:29:46.531]             `+` <- base::`+`
[17:29:46.531]             `<<-` <- base::`<<-`
[17:29:46.531]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:46.531]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:46.531]                   3L)]
[17:29:46.531]             }
[17:29:46.531]             function(cond) {
[17:29:46.531]                 is_error <- inherits(cond, "error")
[17:29:46.531]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:46.531]                   NULL)
[17:29:46.531]                 if (is_error) {
[17:29:46.531]                   sessionInformation <- function() {
[17:29:46.531]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:46.531]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:46.531]                       search = base::search(), system = base::Sys.info())
[17:29:46.531]                   }
[17:29:46.531]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.531]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:46.531]                     cond$call), session = sessionInformation(), 
[17:29:46.531]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:46.531]                   signalCondition(cond)
[17:29:46.531]                 }
[17:29:46.531]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:46.531]                 "immediateCondition"))) {
[17:29:46.531]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:46.531]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.531]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:46.531]                   if (TRUE && !signal) {
[17:29:46.531]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.531]                     {
[17:29:46.531]                       inherits <- base::inherits
[17:29:46.531]                       invokeRestart <- base::invokeRestart
[17:29:46.531]                       is.null <- base::is.null
[17:29:46.531]                       muffled <- FALSE
[17:29:46.531]                       if (inherits(cond, "message")) {
[17:29:46.531]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.531]                         if (muffled) 
[17:29:46.531]                           invokeRestart("muffleMessage")
[17:29:46.531]                       }
[17:29:46.531]                       else if (inherits(cond, "warning")) {
[17:29:46.531]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.531]                         if (muffled) 
[17:29:46.531]                           invokeRestart("muffleWarning")
[17:29:46.531]                       }
[17:29:46.531]                       else if (inherits(cond, "condition")) {
[17:29:46.531]                         if (!is.null(pattern)) {
[17:29:46.531]                           computeRestarts <- base::computeRestarts
[17:29:46.531]                           grepl <- base::grepl
[17:29:46.531]                           restarts <- computeRestarts(cond)
[17:29:46.531]                           for (restart in restarts) {
[17:29:46.531]                             name <- restart$name
[17:29:46.531]                             if (is.null(name)) 
[17:29:46.531]                               next
[17:29:46.531]                             if (!grepl(pattern, name)) 
[17:29:46.531]                               next
[17:29:46.531]                             invokeRestart(restart)
[17:29:46.531]                             muffled <- TRUE
[17:29:46.531]                             break
[17:29:46.531]                           }
[17:29:46.531]                         }
[17:29:46.531]                       }
[17:29:46.531]                       invisible(muffled)
[17:29:46.531]                     }
[17:29:46.531]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.531]                   }
[17:29:46.531]                 }
[17:29:46.531]                 else {
[17:29:46.531]                   if (TRUE) {
[17:29:46.531]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.531]                     {
[17:29:46.531]                       inherits <- base::inherits
[17:29:46.531]                       invokeRestart <- base::invokeRestart
[17:29:46.531]                       is.null <- base::is.null
[17:29:46.531]                       muffled <- FALSE
[17:29:46.531]                       if (inherits(cond, "message")) {
[17:29:46.531]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.531]                         if (muffled) 
[17:29:46.531]                           invokeRestart("muffleMessage")
[17:29:46.531]                       }
[17:29:46.531]                       else if (inherits(cond, "warning")) {
[17:29:46.531]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.531]                         if (muffled) 
[17:29:46.531]                           invokeRestart("muffleWarning")
[17:29:46.531]                       }
[17:29:46.531]                       else if (inherits(cond, "condition")) {
[17:29:46.531]                         if (!is.null(pattern)) {
[17:29:46.531]                           computeRestarts <- base::computeRestarts
[17:29:46.531]                           grepl <- base::grepl
[17:29:46.531]                           restarts <- computeRestarts(cond)
[17:29:46.531]                           for (restart in restarts) {
[17:29:46.531]                             name <- restart$name
[17:29:46.531]                             if (is.null(name)) 
[17:29:46.531]                               next
[17:29:46.531]                             if (!grepl(pattern, name)) 
[17:29:46.531]                               next
[17:29:46.531]                             invokeRestart(restart)
[17:29:46.531]                             muffled <- TRUE
[17:29:46.531]                             break
[17:29:46.531]                           }
[17:29:46.531]                         }
[17:29:46.531]                       }
[17:29:46.531]                       invisible(muffled)
[17:29:46.531]                     }
[17:29:46.531]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.531]                   }
[17:29:46.531]                 }
[17:29:46.531]             }
[17:29:46.531]         }))
[17:29:46.531]     }, error = function(ex) {
[17:29:46.531]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:46.531]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.531]                 ...future.rng), started = ...future.startTime, 
[17:29:46.531]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:46.531]             version = "1.8"), class = "FutureResult")
[17:29:46.531]     }, finally = {
[17:29:46.531]         if (!identical(...future.workdir, getwd())) 
[17:29:46.531]             setwd(...future.workdir)
[17:29:46.531]         {
[17:29:46.531]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:46.531]                 ...future.oldOptions$nwarnings <- NULL
[17:29:46.531]             }
[17:29:46.531]             base::options(...future.oldOptions)
[17:29:46.531]             if (.Platform$OS.type == "windows") {
[17:29:46.531]                 old_names <- names(...future.oldEnvVars)
[17:29:46.531]                 envs <- base::Sys.getenv()
[17:29:46.531]                 names <- names(envs)
[17:29:46.531]                 common <- intersect(names, old_names)
[17:29:46.531]                 added <- setdiff(names, old_names)
[17:29:46.531]                 removed <- setdiff(old_names, names)
[17:29:46.531]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:46.531]                   envs[common]]
[17:29:46.531]                 NAMES <- toupper(changed)
[17:29:46.531]                 args <- list()
[17:29:46.531]                 for (kk in seq_along(NAMES)) {
[17:29:46.531]                   name <- changed[[kk]]
[17:29:46.531]                   NAME <- NAMES[[kk]]
[17:29:46.531]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.531]                     next
[17:29:46.531]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.531]                 }
[17:29:46.531]                 NAMES <- toupper(added)
[17:29:46.531]                 for (kk in seq_along(NAMES)) {
[17:29:46.531]                   name <- added[[kk]]
[17:29:46.531]                   NAME <- NAMES[[kk]]
[17:29:46.531]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.531]                     next
[17:29:46.531]                   args[[name]] <- ""
[17:29:46.531]                 }
[17:29:46.531]                 NAMES <- toupper(removed)
[17:29:46.531]                 for (kk in seq_along(NAMES)) {
[17:29:46.531]                   name <- removed[[kk]]
[17:29:46.531]                   NAME <- NAMES[[kk]]
[17:29:46.531]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.531]                     next
[17:29:46.531]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.531]                 }
[17:29:46.531]                 if (length(args) > 0) 
[17:29:46.531]                   base::do.call(base::Sys.setenv, args = args)
[17:29:46.531]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:46.531]             }
[17:29:46.531]             else {
[17:29:46.531]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:46.531]             }
[17:29:46.531]             {
[17:29:46.531]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:46.531]                   0L) {
[17:29:46.531]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:46.531]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:46.531]                   base::options(opts)
[17:29:46.531]                 }
[17:29:46.531]                 {
[17:29:46.531]                   {
[17:29:46.531]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:46.531]                     NULL
[17:29:46.531]                   }
[17:29:46.531]                   options(future.plan = NULL)
[17:29:46.531]                   if (is.na(NA_character_)) 
[17:29:46.531]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.531]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:46.531]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:46.531]                     .init = FALSE)
[17:29:46.531]                 }
[17:29:46.531]             }
[17:29:46.531]         }
[17:29:46.531]     })
[17:29:46.531]     if (TRUE) {
[17:29:46.531]         base::sink(type = "output", split = FALSE)
[17:29:46.531]         if (TRUE) {
[17:29:46.531]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:46.531]         }
[17:29:46.531]         else {
[17:29:46.531]             ...future.result["stdout"] <- base::list(NULL)
[17:29:46.531]         }
[17:29:46.531]         base::close(...future.stdout)
[17:29:46.531]         ...future.stdout <- NULL
[17:29:46.531]     }
[17:29:46.531]     ...future.result$conditions <- ...future.conditions
[17:29:46.531]     ...future.result$finished <- base::Sys.time()
[17:29:46.531]     ...future.result
[17:29:46.531] }
[17:29:46.539] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:46.539] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:46.540] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:46.540] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:46.541] MultisessionFuture started
[17:29:46.541] - Launch lazy future ... done
[17:29:46.541] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_1-648580'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001add822fae0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:29:46.560] receiveMessageFromWorker() for ClusterFuture ...
[17:29:46.560] - Validating connection of MultisessionFuture
[17:29:46.561] - received message: FutureResult
[17:29:46.561] - Received FutureResult
[17:29:46.561] - Erased future from FutureRegistry
[17:29:46.561] result() for ClusterFuture ...
[17:29:46.562] - result already collected: FutureResult
[17:29:46.562] result() for ClusterFuture ... done
[17:29:46.562] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.562] getGlobalsAndPackages() ...
[17:29:46.562] Searching for globals...
[17:29:46.564] - globals found: [3] '{', 'sample', 'x'
[17:29:46.564] Searching for globals ... DONE
[17:29:46.564] Resolving globals: FALSE
[17:29:46.565] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:46.565] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:46.565] - globals: [1] 'x'
[17:29:46.566] 
[17:29:46.566] getGlobalsAndPackages() ... DONE
[17:29:46.566] run() for 'Future' ...
[17:29:46.566] - state: 'created'
[17:29:46.567] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:46.585] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.585] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:46.585]   - Field: 'node'
[17:29:46.586]   - Field: 'label'
[17:29:46.586]   - Field: 'local'
[17:29:46.586]   - Field: 'owner'
[17:29:46.586]   - Field: 'envir'
[17:29:46.586]   - Field: 'workers'
[17:29:46.587]   - Field: 'packages'
[17:29:46.587]   - Field: 'gc'
[17:29:46.587]   - Field: 'conditions'
[17:29:46.587]   - Field: 'persistent'
[17:29:46.587]   - Field: 'expr'
[17:29:46.587]   - Field: 'uuid'
[17:29:46.588]   - Field: 'seed'
[17:29:46.588]   - Field: 'version'
[17:29:46.588]   - Field: 'result'
[17:29:46.588]   - Field: 'asynchronous'
[17:29:46.588]   - Field: 'calls'
[17:29:46.588]   - Field: 'globals'
[17:29:46.589]   - Field: 'stdout'
[17:29:46.589]   - Field: 'earlySignal'
[17:29:46.589]   - Field: 'lazy'
[17:29:46.589]   - Field: 'state'
[17:29:46.589] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:46.590] - Launch lazy future ...
[17:29:46.590] Packages needed by the future expression (n = 0): <none>
[17:29:46.590] Packages needed by future strategies (n = 0): <none>
[17:29:46.591] {
[17:29:46.591]     {
[17:29:46.591]         {
[17:29:46.591]             ...future.startTime <- base::Sys.time()
[17:29:46.591]             {
[17:29:46.591]                 {
[17:29:46.591]                   {
[17:29:46.591]                     {
[17:29:46.591]                       base::local({
[17:29:46.591]                         has_future <- base::requireNamespace("future", 
[17:29:46.591]                           quietly = TRUE)
[17:29:46.591]                         if (has_future) {
[17:29:46.591]                           ns <- base::getNamespace("future")
[17:29:46.591]                           version <- ns[[".package"]][["version"]]
[17:29:46.591]                           if (is.null(version)) 
[17:29:46.591]                             version <- utils::packageVersion("future")
[17:29:46.591]                         }
[17:29:46.591]                         else {
[17:29:46.591]                           version <- NULL
[17:29:46.591]                         }
[17:29:46.591]                         if (!has_future || version < "1.8.0") {
[17:29:46.591]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:46.591]                             "", base::R.version$version.string), 
[17:29:46.591]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:46.591]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:46.591]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:46.591]                               "release", "version")], collapse = " "), 
[17:29:46.591]                             hostname = base::Sys.info()[["nodename"]])
[17:29:46.591]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:46.591]                             info)
[17:29:46.591]                           info <- base::paste(info, collapse = "; ")
[17:29:46.591]                           if (!has_future) {
[17:29:46.591]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:46.591]                               info)
[17:29:46.591]                           }
[17:29:46.591]                           else {
[17:29:46.591]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:46.591]                               info, version)
[17:29:46.591]                           }
[17:29:46.591]                           base::stop(msg)
[17:29:46.591]                         }
[17:29:46.591]                       })
[17:29:46.591]                     }
[17:29:46.591]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:46.591]                     base::options(mc.cores = 1L)
[17:29:46.591]                   }
[17:29:46.591]                   ...future.strategy.old <- future::plan("list")
[17:29:46.591]                   options(future.plan = NULL)
[17:29:46.591]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.591]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:46.591]                 }
[17:29:46.591]                 ...future.workdir <- getwd()
[17:29:46.591]             }
[17:29:46.591]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:46.591]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:46.591]         }
[17:29:46.591]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:46.591]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:46.591]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:46.591]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:46.591]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:46.591]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:46.591]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:46.591]             base::names(...future.oldOptions))
[17:29:46.591]     }
[17:29:46.591]     if (FALSE) {
[17:29:46.591]     }
[17:29:46.591]     else {
[17:29:46.591]         if (TRUE) {
[17:29:46.591]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:46.591]                 open = "w")
[17:29:46.591]         }
[17:29:46.591]         else {
[17:29:46.591]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:46.591]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:46.591]         }
[17:29:46.591]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:46.591]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:46.591]             base::sink(type = "output", split = FALSE)
[17:29:46.591]             base::close(...future.stdout)
[17:29:46.591]         }, add = TRUE)
[17:29:46.591]     }
[17:29:46.591]     ...future.frame <- base::sys.nframe()
[17:29:46.591]     ...future.conditions <- base::list()
[17:29:46.591]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:46.591]     if (FALSE) {
[17:29:46.591]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:46.591]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:46.591]     }
[17:29:46.591]     ...future.result <- base::tryCatch({
[17:29:46.591]         base::withCallingHandlers({
[17:29:46.591]             ...future.value <- base::withVisible(base::local({
[17:29:46.591]                 ...future.makeSendCondition <- base::local({
[17:29:46.591]                   sendCondition <- NULL
[17:29:46.591]                   function(frame = 1L) {
[17:29:46.591]                     if (is.function(sendCondition)) 
[17:29:46.591]                       return(sendCondition)
[17:29:46.591]                     ns <- getNamespace("parallel")
[17:29:46.591]                     if (exists("sendData", mode = "function", 
[17:29:46.591]                       envir = ns)) {
[17:29:46.591]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:46.591]                         envir = ns)
[17:29:46.591]                       envir <- sys.frame(frame)
[17:29:46.591]                       master <- NULL
[17:29:46.591]                       while (!identical(envir, .GlobalEnv) && 
[17:29:46.591]                         !identical(envir, emptyenv())) {
[17:29:46.591]                         if (exists("master", mode = "list", envir = envir, 
[17:29:46.591]                           inherits = FALSE)) {
[17:29:46.591]                           master <- get("master", mode = "list", 
[17:29:46.591]                             envir = envir, inherits = FALSE)
[17:29:46.591]                           if (inherits(master, c("SOCKnode", 
[17:29:46.591]                             "SOCK0node"))) {
[17:29:46.591]                             sendCondition <<- function(cond) {
[17:29:46.591]                               data <- list(type = "VALUE", value = cond, 
[17:29:46.591]                                 success = TRUE)
[17:29:46.591]                               parallel_sendData(master, data)
[17:29:46.591]                             }
[17:29:46.591]                             return(sendCondition)
[17:29:46.591]                           }
[17:29:46.591]                         }
[17:29:46.591]                         frame <- frame + 1L
[17:29:46.591]                         envir <- sys.frame(frame)
[17:29:46.591]                       }
[17:29:46.591]                     }
[17:29:46.591]                     sendCondition <<- function(cond) NULL
[17:29:46.591]                   }
[17:29:46.591]                 })
[17:29:46.591]                 withCallingHandlers({
[17:29:46.591]                   {
[17:29:46.591]                     sample(x, size = 1L)
[17:29:46.591]                   }
[17:29:46.591]                 }, immediateCondition = function(cond) {
[17:29:46.591]                   sendCondition <- ...future.makeSendCondition()
[17:29:46.591]                   sendCondition(cond)
[17:29:46.591]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.591]                   {
[17:29:46.591]                     inherits <- base::inherits
[17:29:46.591]                     invokeRestart <- base::invokeRestart
[17:29:46.591]                     is.null <- base::is.null
[17:29:46.591]                     muffled <- FALSE
[17:29:46.591]                     if (inherits(cond, "message")) {
[17:29:46.591]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:46.591]                       if (muffled) 
[17:29:46.591]                         invokeRestart("muffleMessage")
[17:29:46.591]                     }
[17:29:46.591]                     else if (inherits(cond, "warning")) {
[17:29:46.591]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:46.591]                       if (muffled) 
[17:29:46.591]                         invokeRestart("muffleWarning")
[17:29:46.591]                     }
[17:29:46.591]                     else if (inherits(cond, "condition")) {
[17:29:46.591]                       if (!is.null(pattern)) {
[17:29:46.591]                         computeRestarts <- base::computeRestarts
[17:29:46.591]                         grepl <- base::grepl
[17:29:46.591]                         restarts <- computeRestarts(cond)
[17:29:46.591]                         for (restart in restarts) {
[17:29:46.591]                           name <- restart$name
[17:29:46.591]                           if (is.null(name)) 
[17:29:46.591]                             next
[17:29:46.591]                           if (!grepl(pattern, name)) 
[17:29:46.591]                             next
[17:29:46.591]                           invokeRestart(restart)
[17:29:46.591]                           muffled <- TRUE
[17:29:46.591]                           break
[17:29:46.591]                         }
[17:29:46.591]                       }
[17:29:46.591]                     }
[17:29:46.591]                     invisible(muffled)
[17:29:46.591]                   }
[17:29:46.591]                   muffleCondition(cond)
[17:29:46.591]                 })
[17:29:46.591]             }))
[17:29:46.591]             future::FutureResult(value = ...future.value$value, 
[17:29:46.591]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.591]                   ...future.rng), globalenv = if (FALSE) 
[17:29:46.591]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:46.591]                     ...future.globalenv.names))
[17:29:46.591]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:46.591]         }, condition = base::local({
[17:29:46.591]             c <- base::c
[17:29:46.591]             inherits <- base::inherits
[17:29:46.591]             invokeRestart <- base::invokeRestart
[17:29:46.591]             length <- base::length
[17:29:46.591]             list <- base::list
[17:29:46.591]             seq.int <- base::seq.int
[17:29:46.591]             signalCondition <- base::signalCondition
[17:29:46.591]             sys.calls <- base::sys.calls
[17:29:46.591]             `[[` <- base::`[[`
[17:29:46.591]             `+` <- base::`+`
[17:29:46.591]             `<<-` <- base::`<<-`
[17:29:46.591]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:46.591]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:46.591]                   3L)]
[17:29:46.591]             }
[17:29:46.591]             function(cond) {
[17:29:46.591]                 is_error <- inherits(cond, "error")
[17:29:46.591]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:46.591]                   NULL)
[17:29:46.591]                 if (is_error) {
[17:29:46.591]                   sessionInformation <- function() {
[17:29:46.591]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:46.591]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:46.591]                       search = base::search(), system = base::Sys.info())
[17:29:46.591]                   }
[17:29:46.591]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.591]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:46.591]                     cond$call), session = sessionInformation(), 
[17:29:46.591]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:46.591]                   signalCondition(cond)
[17:29:46.591]                 }
[17:29:46.591]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:46.591]                 "immediateCondition"))) {
[17:29:46.591]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:46.591]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.591]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:46.591]                   if (TRUE && !signal) {
[17:29:46.591]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.591]                     {
[17:29:46.591]                       inherits <- base::inherits
[17:29:46.591]                       invokeRestart <- base::invokeRestart
[17:29:46.591]                       is.null <- base::is.null
[17:29:46.591]                       muffled <- FALSE
[17:29:46.591]                       if (inherits(cond, "message")) {
[17:29:46.591]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.591]                         if (muffled) 
[17:29:46.591]                           invokeRestart("muffleMessage")
[17:29:46.591]                       }
[17:29:46.591]                       else if (inherits(cond, "warning")) {
[17:29:46.591]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.591]                         if (muffled) 
[17:29:46.591]                           invokeRestart("muffleWarning")
[17:29:46.591]                       }
[17:29:46.591]                       else if (inherits(cond, "condition")) {
[17:29:46.591]                         if (!is.null(pattern)) {
[17:29:46.591]                           computeRestarts <- base::computeRestarts
[17:29:46.591]                           grepl <- base::grepl
[17:29:46.591]                           restarts <- computeRestarts(cond)
[17:29:46.591]                           for (restart in restarts) {
[17:29:46.591]                             name <- restart$name
[17:29:46.591]                             if (is.null(name)) 
[17:29:46.591]                               next
[17:29:46.591]                             if (!grepl(pattern, name)) 
[17:29:46.591]                               next
[17:29:46.591]                             invokeRestart(restart)
[17:29:46.591]                             muffled <- TRUE
[17:29:46.591]                             break
[17:29:46.591]                           }
[17:29:46.591]                         }
[17:29:46.591]                       }
[17:29:46.591]                       invisible(muffled)
[17:29:46.591]                     }
[17:29:46.591]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.591]                   }
[17:29:46.591]                 }
[17:29:46.591]                 else {
[17:29:46.591]                   if (TRUE) {
[17:29:46.591]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.591]                     {
[17:29:46.591]                       inherits <- base::inherits
[17:29:46.591]                       invokeRestart <- base::invokeRestart
[17:29:46.591]                       is.null <- base::is.null
[17:29:46.591]                       muffled <- FALSE
[17:29:46.591]                       if (inherits(cond, "message")) {
[17:29:46.591]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.591]                         if (muffled) 
[17:29:46.591]                           invokeRestart("muffleMessage")
[17:29:46.591]                       }
[17:29:46.591]                       else if (inherits(cond, "warning")) {
[17:29:46.591]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.591]                         if (muffled) 
[17:29:46.591]                           invokeRestart("muffleWarning")
[17:29:46.591]                       }
[17:29:46.591]                       else if (inherits(cond, "condition")) {
[17:29:46.591]                         if (!is.null(pattern)) {
[17:29:46.591]                           computeRestarts <- base::computeRestarts
[17:29:46.591]                           grepl <- base::grepl
[17:29:46.591]                           restarts <- computeRestarts(cond)
[17:29:46.591]                           for (restart in restarts) {
[17:29:46.591]                             name <- restart$name
[17:29:46.591]                             if (is.null(name)) 
[17:29:46.591]                               next
[17:29:46.591]                             if (!grepl(pattern, name)) 
[17:29:46.591]                               next
[17:29:46.591]                             invokeRestart(restart)
[17:29:46.591]                             muffled <- TRUE
[17:29:46.591]                             break
[17:29:46.591]                           }
[17:29:46.591]                         }
[17:29:46.591]                       }
[17:29:46.591]                       invisible(muffled)
[17:29:46.591]                     }
[17:29:46.591]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.591]                   }
[17:29:46.591]                 }
[17:29:46.591]             }
[17:29:46.591]         }))
[17:29:46.591]     }, error = function(ex) {
[17:29:46.591]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:46.591]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.591]                 ...future.rng), started = ...future.startTime, 
[17:29:46.591]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:46.591]             version = "1.8"), class = "FutureResult")
[17:29:46.591]     }, finally = {
[17:29:46.591]         if (!identical(...future.workdir, getwd())) 
[17:29:46.591]             setwd(...future.workdir)
[17:29:46.591]         {
[17:29:46.591]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:46.591]                 ...future.oldOptions$nwarnings <- NULL
[17:29:46.591]             }
[17:29:46.591]             base::options(...future.oldOptions)
[17:29:46.591]             if (.Platform$OS.type == "windows") {
[17:29:46.591]                 old_names <- names(...future.oldEnvVars)
[17:29:46.591]                 envs <- base::Sys.getenv()
[17:29:46.591]                 names <- names(envs)
[17:29:46.591]                 common <- intersect(names, old_names)
[17:29:46.591]                 added <- setdiff(names, old_names)
[17:29:46.591]                 removed <- setdiff(old_names, names)
[17:29:46.591]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:46.591]                   envs[common]]
[17:29:46.591]                 NAMES <- toupper(changed)
[17:29:46.591]                 args <- list()
[17:29:46.591]                 for (kk in seq_along(NAMES)) {
[17:29:46.591]                   name <- changed[[kk]]
[17:29:46.591]                   NAME <- NAMES[[kk]]
[17:29:46.591]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.591]                     next
[17:29:46.591]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.591]                 }
[17:29:46.591]                 NAMES <- toupper(added)
[17:29:46.591]                 for (kk in seq_along(NAMES)) {
[17:29:46.591]                   name <- added[[kk]]
[17:29:46.591]                   NAME <- NAMES[[kk]]
[17:29:46.591]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.591]                     next
[17:29:46.591]                   args[[name]] <- ""
[17:29:46.591]                 }
[17:29:46.591]                 NAMES <- toupper(removed)
[17:29:46.591]                 for (kk in seq_along(NAMES)) {
[17:29:46.591]                   name <- removed[[kk]]
[17:29:46.591]                   NAME <- NAMES[[kk]]
[17:29:46.591]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.591]                     next
[17:29:46.591]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.591]                 }
[17:29:46.591]                 if (length(args) > 0) 
[17:29:46.591]                   base::do.call(base::Sys.setenv, args = args)
[17:29:46.591]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:46.591]             }
[17:29:46.591]             else {
[17:29:46.591]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:46.591]             }
[17:29:46.591]             {
[17:29:46.591]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:46.591]                   0L) {
[17:29:46.591]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:46.591]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:46.591]                   base::options(opts)
[17:29:46.591]                 }
[17:29:46.591]                 {
[17:29:46.591]                   {
[17:29:46.591]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:46.591]                     NULL
[17:29:46.591]                   }
[17:29:46.591]                   options(future.plan = NULL)
[17:29:46.591]                   if (is.na(NA_character_)) 
[17:29:46.591]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.591]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:46.591]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:46.591]                     .init = FALSE)
[17:29:46.591]                 }
[17:29:46.591]             }
[17:29:46.591]         }
[17:29:46.591]     })
[17:29:46.591]     if (TRUE) {
[17:29:46.591]         base::sink(type = "output", split = FALSE)
[17:29:46.591]         if (TRUE) {
[17:29:46.591]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:46.591]         }
[17:29:46.591]         else {
[17:29:46.591]             ...future.result["stdout"] <- base::list(NULL)
[17:29:46.591]         }
[17:29:46.591]         base::close(...future.stdout)
[17:29:46.591]         ...future.stdout <- NULL
[17:29:46.591]     }
[17:29:46.591]     ...future.result$conditions <- ...future.conditions
[17:29:46.591]     ...future.result$finished <- base::Sys.time()
[17:29:46.591]     ...future.result
[17:29:46.591] }
[17:29:46.596] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:46.596] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:46.597] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:46.598] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:46.598] MultisessionFuture started
[17:29:46.599] - Launch lazy future ... done
[17:29:46.599] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_2-836452'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001add822fae0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:29:46.615] receiveMessageFromWorker() for ClusterFuture ...
[17:29:46.616] - Validating connection of MultisessionFuture
[17:29:46.616] - received message: FutureResult
[17:29:46.616] - Received FutureResult
[17:29:46.616] - Erased future from FutureRegistry
[17:29:46.617] result() for ClusterFuture ...
[17:29:46.617] - result already collected: FutureResult
[17:29:46.617] result() for ClusterFuture ... done
[17:29:46.617] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.617] getGlobalsAndPackages() ...
[17:29:46.618] Searching for globals...
[17:29:46.619] - globals found: [3] '{', 'sample', 'x'
[17:29:46.619] Searching for globals ... DONE
[17:29:46.619] Resolving globals: FALSE
[17:29:46.620] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:46.620] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:46.621] - globals: [1] 'x'
[17:29:46.621] 
[17:29:46.621] getGlobalsAndPackages() ... DONE
[17:29:46.621] run() for 'Future' ...
[17:29:46.622] - state: 'created'
[17:29:46.622] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:46.637] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.637] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:46.637]   - Field: 'node'
[17:29:46.638]   - Field: 'label'
[17:29:46.638]   - Field: 'local'
[17:29:46.638]   - Field: 'owner'
[17:29:46.638]   - Field: 'envir'
[17:29:46.638]   - Field: 'workers'
[17:29:46.639]   - Field: 'packages'
[17:29:46.639]   - Field: 'gc'
[17:29:46.639]   - Field: 'conditions'
[17:29:46.639]   - Field: 'persistent'
[17:29:46.640]   - Field: 'expr'
[17:29:46.640]   - Field: 'uuid'
[17:29:46.640]   - Field: 'seed'
[17:29:46.640]   - Field: 'version'
[17:29:46.641]   - Field: 'result'
[17:29:46.641]   - Field: 'asynchronous'
[17:29:46.641]   - Field: 'calls'
[17:29:46.642]   - Field: 'globals'
[17:29:46.642]   - Field: 'stdout'
[17:29:46.642]   - Field: 'earlySignal'
[17:29:46.642]   - Field: 'lazy'
[17:29:46.642]   - Field: 'state'
[17:29:46.642] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:46.643] - Launch lazy future ...
[17:29:46.643] Packages needed by the future expression (n = 0): <none>
[17:29:46.643] Packages needed by future strategies (n = 0): <none>
[17:29:46.644] {
[17:29:46.644]     {
[17:29:46.644]         {
[17:29:46.644]             ...future.startTime <- base::Sys.time()
[17:29:46.644]             {
[17:29:46.644]                 {
[17:29:46.644]                   {
[17:29:46.644]                     {
[17:29:46.644]                       base::local({
[17:29:46.644]                         has_future <- base::requireNamespace("future", 
[17:29:46.644]                           quietly = TRUE)
[17:29:46.644]                         if (has_future) {
[17:29:46.644]                           ns <- base::getNamespace("future")
[17:29:46.644]                           version <- ns[[".package"]][["version"]]
[17:29:46.644]                           if (is.null(version)) 
[17:29:46.644]                             version <- utils::packageVersion("future")
[17:29:46.644]                         }
[17:29:46.644]                         else {
[17:29:46.644]                           version <- NULL
[17:29:46.644]                         }
[17:29:46.644]                         if (!has_future || version < "1.8.0") {
[17:29:46.644]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:46.644]                             "", base::R.version$version.string), 
[17:29:46.644]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:46.644]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:46.644]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:46.644]                               "release", "version")], collapse = " "), 
[17:29:46.644]                             hostname = base::Sys.info()[["nodename"]])
[17:29:46.644]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:46.644]                             info)
[17:29:46.644]                           info <- base::paste(info, collapse = "; ")
[17:29:46.644]                           if (!has_future) {
[17:29:46.644]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:46.644]                               info)
[17:29:46.644]                           }
[17:29:46.644]                           else {
[17:29:46.644]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:46.644]                               info, version)
[17:29:46.644]                           }
[17:29:46.644]                           base::stop(msg)
[17:29:46.644]                         }
[17:29:46.644]                       })
[17:29:46.644]                     }
[17:29:46.644]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:46.644]                     base::options(mc.cores = 1L)
[17:29:46.644]                   }
[17:29:46.644]                   ...future.strategy.old <- future::plan("list")
[17:29:46.644]                   options(future.plan = NULL)
[17:29:46.644]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.644]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:46.644]                 }
[17:29:46.644]                 ...future.workdir <- getwd()
[17:29:46.644]             }
[17:29:46.644]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:46.644]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:46.644]         }
[17:29:46.644]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:46.644]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:46.644]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:46.644]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:46.644]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:46.644]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:46.644]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:46.644]             base::names(...future.oldOptions))
[17:29:46.644]     }
[17:29:46.644]     if (FALSE) {
[17:29:46.644]     }
[17:29:46.644]     else {
[17:29:46.644]         if (TRUE) {
[17:29:46.644]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:46.644]                 open = "w")
[17:29:46.644]         }
[17:29:46.644]         else {
[17:29:46.644]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:46.644]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:46.644]         }
[17:29:46.644]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:46.644]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:46.644]             base::sink(type = "output", split = FALSE)
[17:29:46.644]             base::close(...future.stdout)
[17:29:46.644]         }, add = TRUE)
[17:29:46.644]     }
[17:29:46.644]     ...future.frame <- base::sys.nframe()
[17:29:46.644]     ...future.conditions <- base::list()
[17:29:46.644]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:46.644]     if (FALSE) {
[17:29:46.644]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:46.644]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:46.644]     }
[17:29:46.644]     ...future.result <- base::tryCatch({
[17:29:46.644]         base::withCallingHandlers({
[17:29:46.644]             ...future.value <- base::withVisible(base::local({
[17:29:46.644]                 ...future.makeSendCondition <- base::local({
[17:29:46.644]                   sendCondition <- NULL
[17:29:46.644]                   function(frame = 1L) {
[17:29:46.644]                     if (is.function(sendCondition)) 
[17:29:46.644]                       return(sendCondition)
[17:29:46.644]                     ns <- getNamespace("parallel")
[17:29:46.644]                     if (exists("sendData", mode = "function", 
[17:29:46.644]                       envir = ns)) {
[17:29:46.644]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:46.644]                         envir = ns)
[17:29:46.644]                       envir <- sys.frame(frame)
[17:29:46.644]                       master <- NULL
[17:29:46.644]                       while (!identical(envir, .GlobalEnv) && 
[17:29:46.644]                         !identical(envir, emptyenv())) {
[17:29:46.644]                         if (exists("master", mode = "list", envir = envir, 
[17:29:46.644]                           inherits = FALSE)) {
[17:29:46.644]                           master <- get("master", mode = "list", 
[17:29:46.644]                             envir = envir, inherits = FALSE)
[17:29:46.644]                           if (inherits(master, c("SOCKnode", 
[17:29:46.644]                             "SOCK0node"))) {
[17:29:46.644]                             sendCondition <<- function(cond) {
[17:29:46.644]                               data <- list(type = "VALUE", value = cond, 
[17:29:46.644]                                 success = TRUE)
[17:29:46.644]                               parallel_sendData(master, data)
[17:29:46.644]                             }
[17:29:46.644]                             return(sendCondition)
[17:29:46.644]                           }
[17:29:46.644]                         }
[17:29:46.644]                         frame <- frame + 1L
[17:29:46.644]                         envir <- sys.frame(frame)
[17:29:46.644]                       }
[17:29:46.644]                     }
[17:29:46.644]                     sendCondition <<- function(cond) NULL
[17:29:46.644]                   }
[17:29:46.644]                 })
[17:29:46.644]                 withCallingHandlers({
[17:29:46.644]                   {
[17:29:46.644]                     sample(x, size = 1L)
[17:29:46.644]                   }
[17:29:46.644]                 }, immediateCondition = function(cond) {
[17:29:46.644]                   sendCondition <- ...future.makeSendCondition()
[17:29:46.644]                   sendCondition(cond)
[17:29:46.644]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.644]                   {
[17:29:46.644]                     inherits <- base::inherits
[17:29:46.644]                     invokeRestart <- base::invokeRestart
[17:29:46.644]                     is.null <- base::is.null
[17:29:46.644]                     muffled <- FALSE
[17:29:46.644]                     if (inherits(cond, "message")) {
[17:29:46.644]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:46.644]                       if (muffled) 
[17:29:46.644]                         invokeRestart("muffleMessage")
[17:29:46.644]                     }
[17:29:46.644]                     else if (inherits(cond, "warning")) {
[17:29:46.644]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:46.644]                       if (muffled) 
[17:29:46.644]                         invokeRestart("muffleWarning")
[17:29:46.644]                     }
[17:29:46.644]                     else if (inherits(cond, "condition")) {
[17:29:46.644]                       if (!is.null(pattern)) {
[17:29:46.644]                         computeRestarts <- base::computeRestarts
[17:29:46.644]                         grepl <- base::grepl
[17:29:46.644]                         restarts <- computeRestarts(cond)
[17:29:46.644]                         for (restart in restarts) {
[17:29:46.644]                           name <- restart$name
[17:29:46.644]                           if (is.null(name)) 
[17:29:46.644]                             next
[17:29:46.644]                           if (!grepl(pattern, name)) 
[17:29:46.644]                             next
[17:29:46.644]                           invokeRestart(restart)
[17:29:46.644]                           muffled <- TRUE
[17:29:46.644]                           break
[17:29:46.644]                         }
[17:29:46.644]                       }
[17:29:46.644]                     }
[17:29:46.644]                     invisible(muffled)
[17:29:46.644]                   }
[17:29:46.644]                   muffleCondition(cond)
[17:29:46.644]                 })
[17:29:46.644]             }))
[17:29:46.644]             future::FutureResult(value = ...future.value$value, 
[17:29:46.644]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.644]                   ...future.rng), globalenv = if (FALSE) 
[17:29:46.644]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:46.644]                     ...future.globalenv.names))
[17:29:46.644]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:46.644]         }, condition = base::local({
[17:29:46.644]             c <- base::c
[17:29:46.644]             inherits <- base::inherits
[17:29:46.644]             invokeRestart <- base::invokeRestart
[17:29:46.644]             length <- base::length
[17:29:46.644]             list <- base::list
[17:29:46.644]             seq.int <- base::seq.int
[17:29:46.644]             signalCondition <- base::signalCondition
[17:29:46.644]             sys.calls <- base::sys.calls
[17:29:46.644]             `[[` <- base::`[[`
[17:29:46.644]             `+` <- base::`+`
[17:29:46.644]             `<<-` <- base::`<<-`
[17:29:46.644]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:46.644]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:46.644]                   3L)]
[17:29:46.644]             }
[17:29:46.644]             function(cond) {
[17:29:46.644]                 is_error <- inherits(cond, "error")
[17:29:46.644]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:46.644]                   NULL)
[17:29:46.644]                 if (is_error) {
[17:29:46.644]                   sessionInformation <- function() {
[17:29:46.644]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:46.644]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:46.644]                       search = base::search(), system = base::Sys.info())
[17:29:46.644]                   }
[17:29:46.644]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.644]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:46.644]                     cond$call), session = sessionInformation(), 
[17:29:46.644]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:46.644]                   signalCondition(cond)
[17:29:46.644]                 }
[17:29:46.644]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:46.644]                 "immediateCondition"))) {
[17:29:46.644]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:46.644]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.644]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:46.644]                   if (TRUE && !signal) {
[17:29:46.644]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.644]                     {
[17:29:46.644]                       inherits <- base::inherits
[17:29:46.644]                       invokeRestart <- base::invokeRestart
[17:29:46.644]                       is.null <- base::is.null
[17:29:46.644]                       muffled <- FALSE
[17:29:46.644]                       if (inherits(cond, "message")) {
[17:29:46.644]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.644]                         if (muffled) 
[17:29:46.644]                           invokeRestart("muffleMessage")
[17:29:46.644]                       }
[17:29:46.644]                       else if (inherits(cond, "warning")) {
[17:29:46.644]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.644]                         if (muffled) 
[17:29:46.644]                           invokeRestart("muffleWarning")
[17:29:46.644]                       }
[17:29:46.644]                       else if (inherits(cond, "condition")) {
[17:29:46.644]                         if (!is.null(pattern)) {
[17:29:46.644]                           computeRestarts <- base::computeRestarts
[17:29:46.644]                           grepl <- base::grepl
[17:29:46.644]                           restarts <- computeRestarts(cond)
[17:29:46.644]                           for (restart in restarts) {
[17:29:46.644]                             name <- restart$name
[17:29:46.644]                             if (is.null(name)) 
[17:29:46.644]                               next
[17:29:46.644]                             if (!grepl(pattern, name)) 
[17:29:46.644]                               next
[17:29:46.644]                             invokeRestart(restart)
[17:29:46.644]                             muffled <- TRUE
[17:29:46.644]                             break
[17:29:46.644]                           }
[17:29:46.644]                         }
[17:29:46.644]                       }
[17:29:46.644]                       invisible(muffled)
[17:29:46.644]                     }
[17:29:46.644]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.644]                   }
[17:29:46.644]                 }
[17:29:46.644]                 else {
[17:29:46.644]                   if (TRUE) {
[17:29:46.644]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.644]                     {
[17:29:46.644]                       inherits <- base::inherits
[17:29:46.644]                       invokeRestart <- base::invokeRestart
[17:29:46.644]                       is.null <- base::is.null
[17:29:46.644]                       muffled <- FALSE
[17:29:46.644]                       if (inherits(cond, "message")) {
[17:29:46.644]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.644]                         if (muffled) 
[17:29:46.644]                           invokeRestart("muffleMessage")
[17:29:46.644]                       }
[17:29:46.644]                       else if (inherits(cond, "warning")) {
[17:29:46.644]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.644]                         if (muffled) 
[17:29:46.644]                           invokeRestart("muffleWarning")
[17:29:46.644]                       }
[17:29:46.644]                       else if (inherits(cond, "condition")) {
[17:29:46.644]                         if (!is.null(pattern)) {
[17:29:46.644]                           computeRestarts <- base::computeRestarts
[17:29:46.644]                           grepl <- base::grepl
[17:29:46.644]                           restarts <- computeRestarts(cond)
[17:29:46.644]                           for (restart in restarts) {
[17:29:46.644]                             name <- restart$name
[17:29:46.644]                             if (is.null(name)) 
[17:29:46.644]                               next
[17:29:46.644]                             if (!grepl(pattern, name)) 
[17:29:46.644]                               next
[17:29:46.644]                             invokeRestart(restart)
[17:29:46.644]                             muffled <- TRUE
[17:29:46.644]                             break
[17:29:46.644]                           }
[17:29:46.644]                         }
[17:29:46.644]                       }
[17:29:46.644]                       invisible(muffled)
[17:29:46.644]                     }
[17:29:46.644]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.644]                   }
[17:29:46.644]                 }
[17:29:46.644]             }
[17:29:46.644]         }))
[17:29:46.644]     }, error = function(ex) {
[17:29:46.644]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:46.644]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.644]                 ...future.rng), started = ...future.startTime, 
[17:29:46.644]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:46.644]             version = "1.8"), class = "FutureResult")
[17:29:46.644]     }, finally = {
[17:29:46.644]         if (!identical(...future.workdir, getwd())) 
[17:29:46.644]             setwd(...future.workdir)
[17:29:46.644]         {
[17:29:46.644]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:46.644]                 ...future.oldOptions$nwarnings <- NULL
[17:29:46.644]             }
[17:29:46.644]             base::options(...future.oldOptions)
[17:29:46.644]             if (.Platform$OS.type == "windows") {
[17:29:46.644]                 old_names <- names(...future.oldEnvVars)
[17:29:46.644]                 envs <- base::Sys.getenv()
[17:29:46.644]                 names <- names(envs)
[17:29:46.644]                 common <- intersect(names, old_names)
[17:29:46.644]                 added <- setdiff(names, old_names)
[17:29:46.644]                 removed <- setdiff(old_names, names)
[17:29:46.644]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:46.644]                   envs[common]]
[17:29:46.644]                 NAMES <- toupper(changed)
[17:29:46.644]                 args <- list()
[17:29:46.644]                 for (kk in seq_along(NAMES)) {
[17:29:46.644]                   name <- changed[[kk]]
[17:29:46.644]                   NAME <- NAMES[[kk]]
[17:29:46.644]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.644]                     next
[17:29:46.644]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.644]                 }
[17:29:46.644]                 NAMES <- toupper(added)
[17:29:46.644]                 for (kk in seq_along(NAMES)) {
[17:29:46.644]                   name <- added[[kk]]
[17:29:46.644]                   NAME <- NAMES[[kk]]
[17:29:46.644]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.644]                     next
[17:29:46.644]                   args[[name]] <- ""
[17:29:46.644]                 }
[17:29:46.644]                 NAMES <- toupper(removed)
[17:29:46.644]                 for (kk in seq_along(NAMES)) {
[17:29:46.644]                   name <- removed[[kk]]
[17:29:46.644]                   NAME <- NAMES[[kk]]
[17:29:46.644]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.644]                     next
[17:29:46.644]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.644]                 }
[17:29:46.644]                 if (length(args) > 0) 
[17:29:46.644]                   base::do.call(base::Sys.setenv, args = args)
[17:29:46.644]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:46.644]             }
[17:29:46.644]             else {
[17:29:46.644]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:46.644]             }
[17:29:46.644]             {
[17:29:46.644]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:46.644]                   0L) {
[17:29:46.644]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:46.644]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:46.644]                   base::options(opts)
[17:29:46.644]                 }
[17:29:46.644]                 {
[17:29:46.644]                   {
[17:29:46.644]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:46.644]                     NULL
[17:29:46.644]                   }
[17:29:46.644]                   options(future.plan = NULL)
[17:29:46.644]                   if (is.na(NA_character_)) 
[17:29:46.644]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.644]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:46.644]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:46.644]                     .init = FALSE)
[17:29:46.644]                 }
[17:29:46.644]             }
[17:29:46.644]         }
[17:29:46.644]     })
[17:29:46.644]     if (TRUE) {
[17:29:46.644]         base::sink(type = "output", split = FALSE)
[17:29:46.644]         if (TRUE) {
[17:29:46.644]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:46.644]         }
[17:29:46.644]         else {
[17:29:46.644]             ...future.result["stdout"] <- base::list(NULL)
[17:29:46.644]         }
[17:29:46.644]         base::close(...future.stdout)
[17:29:46.644]         ...future.stdout <- NULL
[17:29:46.644]     }
[17:29:46.644]     ...future.result$conditions <- ...future.conditions
[17:29:46.644]     ...future.result$finished <- base::Sys.time()
[17:29:46.644]     ...future.result
[17:29:46.644] }
[17:29:46.652] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:46.652] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:46.653] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:46.653] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:46.654] MultisessionFuture started
[17:29:46.655] - Launch lazy future ... done
[17:29:46.655] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_3-751548'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001add822fae0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:29:46.716] receiveMessageFromWorker() for ClusterFuture ...
[17:29:46.716] - Validating connection of MultisessionFuture
[17:29:46.717] - received message: FutureResult
[17:29:46.717] - Received FutureResult
[17:29:46.718] - Erased future from FutureRegistry
[17:29:46.718] result() for ClusterFuture ...
[17:29:46.718] - result already collected: FutureResult
[17:29:46.719] result() for ClusterFuture ... done
[17:29:46.719] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.719] getGlobalsAndPackages() ...
[17:29:46.720] Searching for globals...
[17:29:46.722] - globals found: [3] '{', 'sample', 'x'
[17:29:46.722] Searching for globals ... DONE
[17:29:46.722] Resolving globals: FALSE
[17:29:46.723] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:46.724] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:46.724] - globals: [1] 'x'
[17:29:46.725] 
[17:29:46.725] getGlobalsAndPackages() ... DONE
[17:29:46.726] run() for 'Future' ...
[17:29:46.726] - state: 'created'
[17:29:46.726] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:46.746] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.747] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:46.747]   - Field: 'node'
[17:29:46.747]   - Field: 'label'
[17:29:46.748]   - Field: 'local'
[17:29:46.748]   - Field: 'owner'
[17:29:46.748]   - Field: 'envir'
[17:29:46.749]   - Field: 'workers'
[17:29:46.749]   - Field: 'packages'
[17:29:46.749]   - Field: 'gc'
[17:29:46.750]   - Field: 'conditions'
[17:29:46.750]   - Field: 'persistent'
[17:29:46.750]   - Field: 'expr'
[17:29:46.751]   - Field: 'uuid'
[17:29:46.751]   - Field: 'seed'
[17:29:46.751]   - Field: 'version'
[17:29:46.752]   - Field: 'result'
[17:29:46.752]   - Field: 'asynchronous'
[17:29:46.752]   - Field: 'calls'
[17:29:46.753]   - Field: 'globals'
[17:29:46.753]   - Field: 'stdout'
[17:29:46.753]   - Field: 'earlySignal'
[17:29:46.753]   - Field: 'lazy'
[17:29:46.754]   - Field: 'state'
[17:29:46.754] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:46.754] - Launch lazy future ...
[17:29:46.754] Packages needed by the future expression (n = 0): <none>
[17:29:46.755] Packages needed by future strategies (n = 0): <none>
[17:29:46.755] {
[17:29:46.755]     {
[17:29:46.755]         {
[17:29:46.755]             ...future.startTime <- base::Sys.time()
[17:29:46.755]             {
[17:29:46.755]                 {
[17:29:46.755]                   {
[17:29:46.755]                     {
[17:29:46.755]                       base::local({
[17:29:46.755]                         has_future <- base::requireNamespace("future", 
[17:29:46.755]                           quietly = TRUE)
[17:29:46.755]                         if (has_future) {
[17:29:46.755]                           ns <- base::getNamespace("future")
[17:29:46.755]                           version <- ns[[".package"]][["version"]]
[17:29:46.755]                           if (is.null(version)) 
[17:29:46.755]                             version <- utils::packageVersion("future")
[17:29:46.755]                         }
[17:29:46.755]                         else {
[17:29:46.755]                           version <- NULL
[17:29:46.755]                         }
[17:29:46.755]                         if (!has_future || version < "1.8.0") {
[17:29:46.755]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:46.755]                             "", base::R.version$version.string), 
[17:29:46.755]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:46.755]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:46.755]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:46.755]                               "release", "version")], collapse = " "), 
[17:29:46.755]                             hostname = base::Sys.info()[["nodename"]])
[17:29:46.755]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:46.755]                             info)
[17:29:46.755]                           info <- base::paste(info, collapse = "; ")
[17:29:46.755]                           if (!has_future) {
[17:29:46.755]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:46.755]                               info)
[17:29:46.755]                           }
[17:29:46.755]                           else {
[17:29:46.755]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:46.755]                               info, version)
[17:29:46.755]                           }
[17:29:46.755]                           base::stop(msg)
[17:29:46.755]                         }
[17:29:46.755]                       })
[17:29:46.755]                     }
[17:29:46.755]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:46.755]                     base::options(mc.cores = 1L)
[17:29:46.755]                   }
[17:29:46.755]                   ...future.strategy.old <- future::plan("list")
[17:29:46.755]                   options(future.plan = NULL)
[17:29:46.755]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.755]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:46.755]                 }
[17:29:46.755]                 ...future.workdir <- getwd()
[17:29:46.755]             }
[17:29:46.755]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:46.755]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:46.755]         }
[17:29:46.755]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:46.755]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:46.755]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:46.755]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:46.755]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:46.755]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:46.755]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:46.755]             base::names(...future.oldOptions))
[17:29:46.755]     }
[17:29:46.755]     if (FALSE) {
[17:29:46.755]     }
[17:29:46.755]     else {
[17:29:46.755]         if (TRUE) {
[17:29:46.755]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:46.755]                 open = "w")
[17:29:46.755]         }
[17:29:46.755]         else {
[17:29:46.755]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:46.755]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:46.755]         }
[17:29:46.755]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:46.755]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:46.755]             base::sink(type = "output", split = FALSE)
[17:29:46.755]             base::close(...future.stdout)
[17:29:46.755]         }, add = TRUE)
[17:29:46.755]     }
[17:29:46.755]     ...future.frame <- base::sys.nframe()
[17:29:46.755]     ...future.conditions <- base::list()
[17:29:46.755]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:46.755]     if (FALSE) {
[17:29:46.755]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:46.755]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:46.755]     }
[17:29:46.755]     ...future.result <- base::tryCatch({
[17:29:46.755]         base::withCallingHandlers({
[17:29:46.755]             ...future.value <- base::withVisible(base::local({
[17:29:46.755]                 ...future.makeSendCondition <- base::local({
[17:29:46.755]                   sendCondition <- NULL
[17:29:46.755]                   function(frame = 1L) {
[17:29:46.755]                     if (is.function(sendCondition)) 
[17:29:46.755]                       return(sendCondition)
[17:29:46.755]                     ns <- getNamespace("parallel")
[17:29:46.755]                     if (exists("sendData", mode = "function", 
[17:29:46.755]                       envir = ns)) {
[17:29:46.755]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:46.755]                         envir = ns)
[17:29:46.755]                       envir <- sys.frame(frame)
[17:29:46.755]                       master <- NULL
[17:29:46.755]                       while (!identical(envir, .GlobalEnv) && 
[17:29:46.755]                         !identical(envir, emptyenv())) {
[17:29:46.755]                         if (exists("master", mode = "list", envir = envir, 
[17:29:46.755]                           inherits = FALSE)) {
[17:29:46.755]                           master <- get("master", mode = "list", 
[17:29:46.755]                             envir = envir, inherits = FALSE)
[17:29:46.755]                           if (inherits(master, c("SOCKnode", 
[17:29:46.755]                             "SOCK0node"))) {
[17:29:46.755]                             sendCondition <<- function(cond) {
[17:29:46.755]                               data <- list(type = "VALUE", value = cond, 
[17:29:46.755]                                 success = TRUE)
[17:29:46.755]                               parallel_sendData(master, data)
[17:29:46.755]                             }
[17:29:46.755]                             return(sendCondition)
[17:29:46.755]                           }
[17:29:46.755]                         }
[17:29:46.755]                         frame <- frame + 1L
[17:29:46.755]                         envir <- sys.frame(frame)
[17:29:46.755]                       }
[17:29:46.755]                     }
[17:29:46.755]                     sendCondition <<- function(cond) NULL
[17:29:46.755]                   }
[17:29:46.755]                 })
[17:29:46.755]                 withCallingHandlers({
[17:29:46.755]                   {
[17:29:46.755]                     sample(x, size = 1L)
[17:29:46.755]                   }
[17:29:46.755]                 }, immediateCondition = function(cond) {
[17:29:46.755]                   sendCondition <- ...future.makeSendCondition()
[17:29:46.755]                   sendCondition(cond)
[17:29:46.755]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.755]                   {
[17:29:46.755]                     inherits <- base::inherits
[17:29:46.755]                     invokeRestart <- base::invokeRestart
[17:29:46.755]                     is.null <- base::is.null
[17:29:46.755]                     muffled <- FALSE
[17:29:46.755]                     if (inherits(cond, "message")) {
[17:29:46.755]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:46.755]                       if (muffled) 
[17:29:46.755]                         invokeRestart("muffleMessage")
[17:29:46.755]                     }
[17:29:46.755]                     else if (inherits(cond, "warning")) {
[17:29:46.755]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:46.755]                       if (muffled) 
[17:29:46.755]                         invokeRestart("muffleWarning")
[17:29:46.755]                     }
[17:29:46.755]                     else if (inherits(cond, "condition")) {
[17:29:46.755]                       if (!is.null(pattern)) {
[17:29:46.755]                         computeRestarts <- base::computeRestarts
[17:29:46.755]                         grepl <- base::grepl
[17:29:46.755]                         restarts <- computeRestarts(cond)
[17:29:46.755]                         for (restart in restarts) {
[17:29:46.755]                           name <- restart$name
[17:29:46.755]                           if (is.null(name)) 
[17:29:46.755]                             next
[17:29:46.755]                           if (!grepl(pattern, name)) 
[17:29:46.755]                             next
[17:29:46.755]                           invokeRestart(restart)
[17:29:46.755]                           muffled <- TRUE
[17:29:46.755]                           break
[17:29:46.755]                         }
[17:29:46.755]                       }
[17:29:46.755]                     }
[17:29:46.755]                     invisible(muffled)
[17:29:46.755]                   }
[17:29:46.755]                   muffleCondition(cond)
[17:29:46.755]                 })
[17:29:46.755]             }))
[17:29:46.755]             future::FutureResult(value = ...future.value$value, 
[17:29:46.755]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.755]                   ...future.rng), globalenv = if (FALSE) 
[17:29:46.755]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:46.755]                     ...future.globalenv.names))
[17:29:46.755]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:46.755]         }, condition = base::local({
[17:29:46.755]             c <- base::c
[17:29:46.755]             inherits <- base::inherits
[17:29:46.755]             invokeRestart <- base::invokeRestart
[17:29:46.755]             length <- base::length
[17:29:46.755]             list <- base::list
[17:29:46.755]             seq.int <- base::seq.int
[17:29:46.755]             signalCondition <- base::signalCondition
[17:29:46.755]             sys.calls <- base::sys.calls
[17:29:46.755]             `[[` <- base::`[[`
[17:29:46.755]             `+` <- base::`+`
[17:29:46.755]             `<<-` <- base::`<<-`
[17:29:46.755]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:46.755]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:46.755]                   3L)]
[17:29:46.755]             }
[17:29:46.755]             function(cond) {
[17:29:46.755]                 is_error <- inherits(cond, "error")
[17:29:46.755]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:46.755]                   NULL)
[17:29:46.755]                 if (is_error) {
[17:29:46.755]                   sessionInformation <- function() {
[17:29:46.755]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:46.755]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:46.755]                       search = base::search(), system = base::Sys.info())
[17:29:46.755]                   }
[17:29:46.755]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.755]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:46.755]                     cond$call), session = sessionInformation(), 
[17:29:46.755]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:46.755]                   signalCondition(cond)
[17:29:46.755]                 }
[17:29:46.755]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:46.755]                 "immediateCondition"))) {
[17:29:46.755]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:46.755]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.755]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:46.755]                   if (TRUE && !signal) {
[17:29:46.755]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.755]                     {
[17:29:46.755]                       inherits <- base::inherits
[17:29:46.755]                       invokeRestart <- base::invokeRestart
[17:29:46.755]                       is.null <- base::is.null
[17:29:46.755]                       muffled <- FALSE
[17:29:46.755]                       if (inherits(cond, "message")) {
[17:29:46.755]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.755]                         if (muffled) 
[17:29:46.755]                           invokeRestart("muffleMessage")
[17:29:46.755]                       }
[17:29:46.755]                       else if (inherits(cond, "warning")) {
[17:29:46.755]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.755]                         if (muffled) 
[17:29:46.755]                           invokeRestart("muffleWarning")
[17:29:46.755]                       }
[17:29:46.755]                       else if (inherits(cond, "condition")) {
[17:29:46.755]                         if (!is.null(pattern)) {
[17:29:46.755]                           computeRestarts <- base::computeRestarts
[17:29:46.755]                           grepl <- base::grepl
[17:29:46.755]                           restarts <- computeRestarts(cond)
[17:29:46.755]                           for (restart in restarts) {
[17:29:46.755]                             name <- restart$name
[17:29:46.755]                             if (is.null(name)) 
[17:29:46.755]                               next
[17:29:46.755]                             if (!grepl(pattern, name)) 
[17:29:46.755]                               next
[17:29:46.755]                             invokeRestart(restart)
[17:29:46.755]                             muffled <- TRUE
[17:29:46.755]                             break
[17:29:46.755]                           }
[17:29:46.755]                         }
[17:29:46.755]                       }
[17:29:46.755]                       invisible(muffled)
[17:29:46.755]                     }
[17:29:46.755]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.755]                   }
[17:29:46.755]                 }
[17:29:46.755]                 else {
[17:29:46.755]                   if (TRUE) {
[17:29:46.755]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.755]                     {
[17:29:46.755]                       inherits <- base::inherits
[17:29:46.755]                       invokeRestart <- base::invokeRestart
[17:29:46.755]                       is.null <- base::is.null
[17:29:46.755]                       muffled <- FALSE
[17:29:46.755]                       if (inherits(cond, "message")) {
[17:29:46.755]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.755]                         if (muffled) 
[17:29:46.755]                           invokeRestart("muffleMessage")
[17:29:46.755]                       }
[17:29:46.755]                       else if (inherits(cond, "warning")) {
[17:29:46.755]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.755]                         if (muffled) 
[17:29:46.755]                           invokeRestart("muffleWarning")
[17:29:46.755]                       }
[17:29:46.755]                       else if (inherits(cond, "condition")) {
[17:29:46.755]                         if (!is.null(pattern)) {
[17:29:46.755]                           computeRestarts <- base::computeRestarts
[17:29:46.755]                           grepl <- base::grepl
[17:29:46.755]                           restarts <- computeRestarts(cond)
[17:29:46.755]                           for (restart in restarts) {
[17:29:46.755]                             name <- restart$name
[17:29:46.755]                             if (is.null(name)) 
[17:29:46.755]                               next
[17:29:46.755]                             if (!grepl(pattern, name)) 
[17:29:46.755]                               next
[17:29:46.755]                             invokeRestart(restart)
[17:29:46.755]                             muffled <- TRUE
[17:29:46.755]                             break
[17:29:46.755]                           }
[17:29:46.755]                         }
[17:29:46.755]                       }
[17:29:46.755]                       invisible(muffled)
[17:29:46.755]                     }
[17:29:46.755]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.755]                   }
[17:29:46.755]                 }
[17:29:46.755]             }
[17:29:46.755]         }))
[17:29:46.755]     }, error = function(ex) {
[17:29:46.755]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:46.755]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.755]                 ...future.rng), started = ...future.startTime, 
[17:29:46.755]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:46.755]             version = "1.8"), class = "FutureResult")
[17:29:46.755]     }, finally = {
[17:29:46.755]         if (!identical(...future.workdir, getwd())) 
[17:29:46.755]             setwd(...future.workdir)
[17:29:46.755]         {
[17:29:46.755]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:46.755]                 ...future.oldOptions$nwarnings <- NULL
[17:29:46.755]             }
[17:29:46.755]             base::options(...future.oldOptions)
[17:29:46.755]             if (.Platform$OS.type == "windows") {
[17:29:46.755]                 old_names <- names(...future.oldEnvVars)
[17:29:46.755]                 envs <- base::Sys.getenv()
[17:29:46.755]                 names <- names(envs)
[17:29:46.755]                 common <- intersect(names, old_names)
[17:29:46.755]                 added <- setdiff(names, old_names)
[17:29:46.755]                 removed <- setdiff(old_names, names)
[17:29:46.755]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:46.755]                   envs[common]]
[17:29:46.755]                 NAMES <- toupper(changed)
[17:29:46.755]                 args <- list()
[17:29:46.755]                 for (kk in seq_along(NAMES)) {
[17:29:46.755]                   name <- changed[[kk]]
[17:29:46.755]                   NAME <- NAMES[[kk]]
[17:29:46.755]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.755]                     next
[17:29:46.755]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.755]                 }
[17:29:46.755]                 NAMES <- toupper(added)
[17:29:46.755]                 for (kk in seq_along(NAMES)) {
[17:29:46.755]                   name <- added[[kk]]
[17:29:46.755]                   NAME <- NAMES[[kk]]
[17:29:46.755]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.755]                     next
[17:29:46.755]                   args[[name]] <- ""
[17:29:46.755]                 }
[17:29:46.755]                 NAMES <- toupper(removed)
[17:29:46.755]                 for (kk in seq_along(NAMES)) {
[17:29:46.755]                   name <- removed[[kk]]
[17:29:46.755]                   NAME <- NAMES[[kk]]
[17:29:46.755]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.755]                     next
[17:29:46.755]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.755]                 }
[17:29:46.755]                 if (length(args) > 0) 
[17:29:46.755]                   base::do.call(base::Sys.setenv, args = args)
[17:29:46.755]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:46.755]             }
[17:29:46.755]             else {
[17:29:46.755]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:46.755]             }
[17:29:46.755]             {
[17:29:46.755]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:46.755]                   0L) {
[17:29:46.755]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:46.755]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:46.755]                   base::options(opts)
[17:29:46.755]                 }
[17:29:46.755]                 {
[17:29:46.755]                   {
[17:29:46.755]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:46.755]                     NULL
[17:29:46.755]                   }
[17:29:46.755]                   options(future.plan = NULL)
[17:29:46.755]                   if (is.na(NA_character_)) 
[17:29:46.755]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.755]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:46.755]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:46.755]                     .init = FALSE)
[17:29:46.755]                 }
[17:29:46.755]             }
[17:29:46.755]         }
[17:29:46.755]     })
[17:29:46.755]     if (TRUE) {
[17:29:46.755]         base::sink(type = "output", split = FALSE)
[17:29:46.755]         if (TRUE) {
[17:29:46.755]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:46.755]         }
[17:29:46.755]         else {
[17:29:46.755]             ...future.result["stdout"] <- base::list(NULL)
[17:29:46.755]         }
[17:29:46.755]         base::close(...future.stdout)
[17:29:46.755]         ...future.stdout <- NULL
[17:29:46.755]     }
[17:29:46.755]     ...future.result$conditions <- ...future.conditions
[17:29:46.755]     ...future.result$finished <- base::Sys.time()
[17:29:46.755]     ...future.result
[17:29:46.755] }
[17:29:46.761] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:46.761] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:46.762] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:46.762] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:46.763] MultisessionFuture started
[17:29:46.763] - Launch lazy future ... done
[17:29:46.763] run() for 'MultisessionFuture' ... done
MultisessionFuture:
Label: 'fsample_4-708572'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001add822fae0
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[17:29:46.779] receiveMessageFromWorker() for ClusterFuture ...
[17:29:46.779] - Validating connection of MultisessionFuture
[17:29:46.780] - received message: FutureResult
[17:29:46.780] - Received FutureResult
[17:29:46.780] - Erased future from FutureRegistry
[17:29:46.780] result() for ClusterFuture ...
[17:29:46.780] - result already collected: FutureResult
[17:29:46.781] result() for ClusterFuture ... done
[17:29:46.781] receiveMessageFromWorker() for ClusterFuture ... done
Resolved: TRUE
Value: <not collected>
Conditions captured: <none>
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.781] resolve() on list ...
[17:29:46.781]  recursive: 0
[17:29:46.781]  length: 4
[17:29:46.782] 
[17:29:46.782] Future #1
[17:29:46.782] result() for ClusterFuture ...
[17:29:46.782] - result already collected: FutureResult
[17:29:46.782] result() for ClusterFuture ... done
[17:29:46.782] result() for ClusterFuture ...
[17:29:46.783] - result already collected: FutureResult
[17:29:46.783] result() for ClusterFuture ... done
[17:29:46.783] signalConditionsASAP(MultisessionFuture, pos=1) ...
[17:29:46.783] - nx: 4
[17:29:46.783] - relay: TRUE
[17:29:46.783] - stdout: TRUE
[17:29:46.784] - signal: TRUE
[17:29:46.784] - resignal: FALSE
[17:29:46.784] - force: TRUE
[17:29:46.784] - relayed: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:46.784] - queued futures: [n=4] FALSE, FALSE, FALSE, FALSE
[17:29:46.784]  - until=1
[17:29:46.785]  - relaying element #1
[17:29:46.785] result() for ClusterFuture ...
[17:29:46.785] - result already collected: FutureResult
[17:29:46.786] result() for ClusterFuture ... done
[17:29:46.786] result() for ClusterFuture ...
[17:29:46.786] - result already collected: FutureResult
[17:29:46.786] result() for ClusterFuture ... done
[17:29:46.787] result() for ClusterFuture ...
[17:29:46.787] - result already collected: FutureResult
[17:29:46.787] result() for ClusterFuture ... done
[17:29:46.788] result() for ClusterFuture ...
[17:29:46.788] - result already collected: FutureResult
[17:29:46.788] result() for ClusterFuture ... done
[17:29:46.789] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:46.789] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:46.789] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[17:29:46.789]  length: 3 (resolved future 1)
[17:29:46.790] Future #2
[17:29:46.790] result() for ClusterFuture ...
[17:29:46.790] - result already collected: FutureResult
[17:29:46.791] result() for ClusterFuture ... done
[17:29:46.791] result() for ClusterFuture ...
[17:29:46.791] - result already collected: FutureResult
[17:29:46.792] result() for ClusterFuture ... done
[17:29:46.792] signalConditionsASAP(MultisessionFuture, pos=2) ...
[17:29:46.792] - nx: 4
[17:29:46.792] - relay: TRUE
[17:29:46.793] - stdout: TRUE
[17:29:46.793] - signal: TRUE
[17:29:46.793] - resignal: FALSE
[17:29:46.794] - force: TRUE
[17:29:46.794] - relayed: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:46.794] - queued futures: [n=4] TRUE, FALSE, FALSE, FALSE
[17:29:46.794]  - until=2
[17:29:46.795]  - relaying element #2
[17:29:46.795] result() for ClusterFuture ...
[17:29:46.795] - result already collected: FutureResult
[17:29:46.796] result() for ClusterFuture ... done
[17:29:46.796] result() for ClusterFuture ...
[17:29:46.796] - result already collected: FutureResult
[17:29:46.796] result() for ClusterFuture ... done
[17:29:46.797] result() for ClusterFuture ...
[17:29:46.797] - result already collected: FutureResult
[17:29:46.797] result() for ClusterFuture ... done
[17:29:46.797] result() for ClusterFuture ...
[17:29:46.798] - result already collected: FutureResult
[17:29:46.798] result() for ClusterFuture ... done
[17:29:46.798] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:46.798] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:46.798] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[17:29:46.799]  length: 2 (resolved future 2)
[17:29:46.799] Future #3
[17:29:46.799] result() for ClusterFuture ...
[17:29:46.800] - result already collected: FutureResult
[17:29:46.800] result() for ClusterFuture ... done
[17:29:46.800] result() for ClusterFuture ...
[17:29:46.800] - result already collected: FutureResult
[17:29:46.800] result() for ClusterFuture ... done
[17:29:46.801] signalConditionsASAP(MultisessionFuture, pos=3) ...
[17:29:46.801] - nx: 4
[17:29:46.801] - relay: TRUE
[17:29:46.801] - stdout: TRUE
[17:29:46.802] - signal: TRUE
[17:29:46.802] - resignal: FALSE
[17:29:46.802] - force: TRUE
[17:29:46.802] - relayed: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:46.802] - queued futures: [n=4] TRUE, TRUE, FALSE, FALSE
[17:29:46.803]  - until=3
[17:29:46.803]  - relaying element #3
[17:29:46.803] result() for ClusterFuture ...
[17:29:46.803] - result already collected: FutureResult
[17:29:46.804] result() for ClusterFuture ... done
[17:29:46.804] result() for ClusterFuture ...
[17:29:46.804] - result already collected: FutureResult
[17:29:46.804] result() for ClusterFuture ... done
[17:29:46.805] result() for ClusterFuture ...
[17:29:46.805] - result already collected: FutureResult
[17:29:46.805] result() for ClusterFuture ... done
[17:29:46.805] result() for ClusterFuture ...
[17:29:46.806] - result already collected: FutureResult
[17:29:46.806] result() for ClusterFuture ... done
[17:29:46.806] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:46.806] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:46.807] signalConditionsASAP(MultisessionFuture, pos=3) ... done
[17:29:46.807]  length: 1 (resolved future 3)
[17:29:46.807] Future #4
[17:29:46.807] result() for ClusterFuture ...
[17:29:46.808] - result already collected: FutureResult
[17:29:46.808] result() for ClusterFuture ... done
[17:29:46.808] result() for ClusterFuture ...
[17:29:46.808] - result already collected: FutureResult
[17:29:46.809] result() for ClusterFuture ... done
[17:29:46.809] signalConditionsASAP(MultisessionFuture, pos=4) ...
[17:29:46.809] - nx: 4
[17:29:46.809] - relay: TRUE
[17:29:46.810] - stdout: TRUE
[17:29:46.810] - signal: TRUE
[17:29:46.810] - resignal: FALSE
[17:29:46.810] - force: TRUE
[17:29:46.810] - relayed: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:46.811] - queued futures: [n=4] TRUE, TRUE, TRUE, FALSE
[17:29:46.811]  - until=4
[17:29:46.811]  - relaying element #4
[17:29:46.811] result() for ClusterFuture ...
[17:29:46.812] - result already collected: FutureResult
[17:29:46.812] result() for ClusterFuture ... done
[17:29:46.812] result() for ClusterFuture ...
[17:29:46.812] - result already collected: FutureResult
[17:29:46.813] result() for ClusterFuture ... done
[17:29:46.813] result() for ClusterFuture ...
[17:29:46.813] - result already collected: FutureResult
[17:29:46.813] result() for ClusterFuture ... done
[17:29:46.814] result() for ClusterFuture ...
[17:29:46.814] - result already collected: FutureResult
[17:29:46.814] result() for ClusterFuture ... done
[17:29:46.814] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:46.815] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:46.815] signalConditionsASAP(MultisessionFuture, pos=4) ... done
[17:29:46.815]  length: 0 (resolved future 4)
[17:29:46.815] Relaying remaining futures
[17:29:46.816] signalConditionsASAP(NULL, pos=0) ...
[17:29:46.816] - nx: 4
[17:29:46.816] - relay: TRUE
[17:29:46.816] - stdout: TRUE
[17:29:46.817] - signal: TRUE
[17:29:46.817] - resignal: FALSE
[17:29:46.817] - force: TRUE
[17:29:46.817] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:46.818] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
 - flush all
[17:29:46.818] - relayed: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:46.818] - queued futures: [n=4] TRUE, TRUE, TRUE, TRUE
[17:29:46.819] signalConditionsASAP(NULL, pos=0) ... done
[17:29:46.819] resolve() on list ... DONE
[17:29:46.820] result() for ClusterFuture ...
[17:29:46.821] - result already collected: FutureResult
[17:29:46.822] result() for ClusterFuture ... done
[17:29:46.822] result() for ClusterFuture ...
[17:29:46.823] - result already collected: FutureResult
[17:29:46.823] result() for ClusterFuture ... done
[17:29:46.823] result() for ClusterFuture ...
[17:29:46.823] - result already collected: FutureResult
[17:29:46.824] result() for ClusterFuture ... done
[17:29:46.824] result() for ClusterFuture ...
[17:29:46.824] - result already collected: FutureResult
[17:29:46.825] result() for ClusterFuture ... done
[17:29:46.825] result() for ClusterFuture ...
[17:29:46.825] - result already collected: FutureResult
[17:29:46.825] result() for ClusterFuture ... done
[17:29:46.826] result() for ClusterFuture ...
[17:29:46.826] - result already collected: FutureResult
[17:29:46.826] result() for ClusterFuture ... done
[17:29:46.827] result() for ClusterFuture ...
[17:29:46.827] - result already collected: FutureResult
[17:29:46.827] result() for ClusterFuture ... done
[17:29:46.827] result() for ClusterFuture ...
[17:29:46.828] - result already collected: FutureResult
[17:29:46.828] result() for ClusterFuture ... done
[[1]]
[1] 0

[[2]]
[1] 2

[[3]]
[1] 2

[[4]]
[1] 2

[17:29:46.829] getGlobalsAndPackages() ...
[17:29:46.829] Searching for globals...
[17:29:46.832] - globals found: [3] '{', 'sample', 'x'
[17:29:46.832] Searching for globals ... DONE
[17:29:46.832] Resolving globals: FALSE
[17:29:46.833] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:46.834] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:46.834] - globals: [1] 'x'
[17:29:46.834] 
[17:29:46.835] getGlobalsAndPackages() ... DONE
[17:29:46.835] run() for 'Future' ...
[17:29:46.836] - state: 'created'
[17:29:46.836] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:46.857] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.857] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:46.858]   - Field: 'node'
[17:29:46.858]   - Field: 'label'
[17:29:46.858]   - Field: 'local'
[17:29:46.858]   - Field: 'owner'
[17:29:46.859]   - Field: 'envir'
[17:29:46.859]   - Field: 'workers'
[17:29:46.859]   - Field: 'packages'
[17:29:46.859]   - Field: 'gc'
[17:29:46.860]   - Field: 'conditions'
[17:29:46.860]   - Field: 'persistent'
[17:29:46.860]   - Field: 'expr'
[17:29:46.860]   - Field: 'uuid'
[17:29:46.861]   - Field: 'seed'
[17:29:46.861]   - Field: 'version'
[17:29:46.861]   - Field: 'result'
[17:29:46.861]   - Field: 'asynchronous'
[17:29:46.861]   - Field: 'calls'
[17:29:46.861]   - Field: 'globals'
[17:29:46.862]   - Field: 'stdout'
[17:29:46.862]   - Field: 'earlySignal'
[17:29:46.862]   - Field: 'lazy'
[17:29:46.862]   - Field: 'state'
[17:29:46.862] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:46.862] - Launch lazy future ...
[17:29:46.863] Packages needed by the future expression (n = 0): <none>
[17:29:46.863] Packages needed by future strategies (n = 0): <none>
[17:29:46.864] {
[17:29:46.864]     {
[17:29:46.864]         {
[17:29:46.864]             ...future.startTime <- base::Sys.time()
[17:29:46.864]             {
[17:29:46.864]                 {
[17:29:46.864]                   {
[17:29:46.864]                     {
[17:29:46.864]                       {
[17:29:46.864]                         base::local({
[17:29:46.864]                           has_future <- base::requireNamespace("future", 
[17:29:46.864]                             quietly = TRUE)
[17:29:46.864]                           if (has_future) {
[17:29:46.864]                             ns <- base::getNamespace("future")
[17:29:46.864]                             version <- ns[[".package"]][["version"]]
[17:29:46.864]                             if (is.null(version)) 
[17:29:46.864]                               version <- utils::packageVersion("future")
[17:29:46.864]                           }
[17:29:46.864]                           else {
[17:29:46.864]                             version <- NULL
[17:29:46.864]                           }
[17:29:46.864]                           if (!has_future || version < "1.8.0") {
[17:29:46.864]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:46.864]                               "", base::R.version$version.string), 
[17:29:46.864]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:46.864]                                 base::R.version$platform, 8 * 
[17:29:46.864]                                   base::.Machine$sizeof.pointer), 
[17:29:46.864]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:46.864]                                 "release", "version")], collapse = " "), 
[17:29:46.864]                               hostname = base::Sys.info()[["nodename"]])
[17:29:46.864]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:46.864]                               info)
[17:29:46.864]                             info <- base::paste(info, collapse = "; ")
[17:29:46.864]                             if (!has_future) {
[17:29:46.864]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:46.864]                                 info)
[17:29:46.864]                             }
[17:29:46.864]                             else {
[17:29:46.864]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:46.864]                                 info, version)
[17:29:46.864]                             }
[17:29:46.864]                             base::stop(msg)
[17:29:46.864]                           }
[17:29:46.864]                         })
[17:29:46.864]                       }
[17:29:46.864]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:46.864]                       base::options(mc.cores = 1L)
[17:29:46.864]                     }
[17:29:46.864]                     ...future.strategy.old <- future::plan("list")
[17:29:46.864]                     options(future.plan = NULL)
[17:29:46.864]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.864]                     future::plan("default", .cleanup = FALSE, 
[17:29:46.864]                       .init = FALSE)
[17:29:46.864]                   }
[17:29:46.864]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[17:29:46.864]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[17:29:46.864]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[17:29:46.864]                 }
[17:29:46.864]                 ...future.workdir <- getwd()
[17:29:46.864]             }
[17:29:46.864]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:46.864]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:46.864]         }
[17:29:46.864]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:46.864]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:46.864]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:46.864]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:46.864]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:46.864]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:46.864]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:46.864]             base::names(...future.oldOptions))
[17:29:46.864]     }
[17:29:46.864]     if (FALSE) {
[17:29:46.864]     }
[17:29:46.864]     else {
[17:29:46.864]         if (TRUE) {
[17:29:46.864]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:46.864]                 open = "w")
[17:29:46.864]         }
[17:29:46.864]         else {
[17:29:46.864]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:46.864]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:46.864]         }
[17:29:46.864]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:46.864]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:46.864]             base::sink(type = "output", split = FALSE)
[17:29:46.864]             base::close(...future.stdout)
[17:29:46.864]         }, add = TRUE)
[17:29:46.864]     }
[17:29:46.864]     ...future.frame <- base::sys.nframe()
[17:29:46.864]     ...future.conditions <- base::list()
[17:29:46.864]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:46.864]     if (FALSE) {
[17:29:46.864]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:46.864]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:46.864]     }
[17:29:46.864]     ...future.result <- base::tryCatch({
[17:29:46.864]         base::withCallingHandlers({
[17:29:46.864]             ...future.value <- base::withVisible(base::local({
[17:29:46.864]                 ...future.makeSendCondition <- base::local({
[17:29:46.864]                   sendCondition <- NULL
[17:29:46.864]                   function(frame = 1L) {
[17:29:46.864]                     if (is.function(sendCondition)) 
[17:29:46.864]                       return(sendCondition)
[17:29:46.864]                     ns <- getNamespace("parallel")
[17:29:46.864]                     if (exists("sendData", mode = "function", 
[17:29:46.864]                       envir = ns)) {
[17:29:46.864]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:46.864]                         envir = ns)
[17:29:46.864]                       envir <- sys.frame(frame)
[17:29:46.864]                       master <- NULL
[17:29:46.864]                       while (!identical(envir, .GlobalEnv) && 
[17:29:46.864]                         !identical(envir, emptyenv())) {
[17:29:46.864]                         if (exists("master", mode = "list", envir = envir, 
[17:29:46.864]                           inherits = FALSE)) {
[17:29:46.864]                           master <- get("master", mode = "list", 
[17:29:46.864]                             envir = envir, inherits = FALSE)
[17:29:46.864]                           if (inherits(master, c("SOCKnode", 
[17:29:46.864]                             "SOCK0node"))) {
[17:29:46.864]                             sendCondition <<- function(cond) {
[17:29:46.864]                               data <- list(type = "VALUE", value = cond, 
[17:29:46.864]                                 success = TRUE)
[17:29:46.864]                               parallel_sendData(master, data)
[17:29:46.864]                             }
[17:29:46.864]                             return(sendCondition)
[17:29:46.864]                           }
[17:29:46.864]                         }
[17:29:46.864]                         frame <- frame + 1L
[17:29:46.864]                         envir <- sys.frame(frame)
[17:29:46.864]                       }
[17:29:46.864]                     }
[17:29:46.864]                     sendCondition <<- function(cond) NULL
[17:29:46.864]                   }
[17:29:46.864]                 })
[17:29:46.864]                 withCallingHandlers({
[17:29:46.864]                   {
[17:29:46.864]                     sample(x, size = 1L)
[17:29:46.864]                   }
[17:29:46.864]                 }, immediateCondition = function(cond) {
[17:29:46.864]                   sendCondition <- ...future.makeSendCondition()
[17:29:46.864]                   sendCondition(cond)
[17:29:46.864]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.864]                   {
[17:29:46.864]                     inherits <- base::inherits
[17:29:46.864]                     invokeRestart <- base::invokeRestart
[17:29:46.864]                     is.null <- base::is.null
[17:29:46.864]                     muffled <- FALSE
[17:29:46.864]                     if (inherits(cond, "message")) {
[17:29:46.864]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:46.864]                       if (muffled) 
[17:29:46.864]                         invokeRestart("muffleMessage")
[17:29:46.864]                     }
[17:29:46.864]                     else if (inherits(cond, "warning")) {
[17:29:46.864]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:46.864]                       if (muffled) 
[17:29:46.864]                         invokeRestart("muffleWarning")
[17:29:46.864]                     }
[17:29:46.864]                     else if (inherits(cond, "condition")) {
[17:29:46.864]                       if (!is.null(pattern)) {
[17:29:46.864]                         computeRestarts <- base::computeRestarts
[17:29:46.864]                         grepl <- base::grepl
[17:29:46.864]                         restarts <- computeRestarts(cond)
[17:29:46.864]                         for (restart in restarts) {
[17:29:46.864]                           name <- restart$name
[17:29:46.864]                           if (is.null(name)) 
[17:29:46.864]                             next
[17:29:46.864]                           if (!grepl(pattern, name)) 
[17:29:46.864]                             next
[17:29:46.864]                           invokeRestart(restart)
[17:29:46.864]                           muffled <- TRUE
[17:29:46.864]                           break
[17:29:46.864]                         }
[17:29:46.864]                       }
[17:29:46.864]                     }
[17:29:46.864]                     invisible(muffled)
[17:29:46.864]                   }
[17:29:46.864]                   muffleCondition(cond)
[17:29:46.864]                 })
[17:29:46.864]             }))
[17:29:46.864]             future::FutureResult(value = ...future.value$value, 
[17:29:46.864]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.864]                   ...future.rng), globalenv = if (FALSE) 
[17:29:46.864]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:46.864]                     ...future.globalenv.names))
[17:29:46.864]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:46.864]         }, condition = base::local({
[17:29:46.864]             c <- base::c
[17:29:46.864]             inherits <- base::inherits
[17:29:46.864]             invokeRestart <- base::invokeRestart
[17:29:46.864]             length <- base::length
[17:29:46.864]             list <- base::list
[17:29:46.864]             seq.int <- base::seq.int
[17:29:46.864]             signalCondition <- base::signalCondition
[17:29:46.864]             sys.calls <- base::sys.calls
[17:29:46.864]             `[[` <- base::`[[`
[17:29:46.864]             `+` <- base::`+`
[17:29:46.864]             `<<-` <- base::`<<-`
[17:29:46.864]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:46.864]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:46.864]                   3L)]
[17:29:46.864]             }
[17:29:46.864]             function(cond) {
[17:29:46.864]                 is_error <- inherits(cond, "error")
[17:29:46.864]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:46.864]                   NULL)
[17:29:46.864]                 if (is_error) {
[17:29:46.864]                   sessionInformation <- function() {
[17:29:46.864]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:46.864]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:46.864]                       search = base::search(), system = base::Sys.info())
[17:29:46.864]                   }
[17:29:46.864]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.864]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:46.864]                     cond$call), session = sessionInformation(), 
[17:29:46.864]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:46.864]                   signalCondition(cond)
[17:29:46.864]                 }
[17:29:46.864]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:46.864]                 "immediateCondition"))) {
[17:29:46.864]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:46.864]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.864]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:46.864]                   if (TRUE && !signal) {
[17:29:46.864]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.864]                     {
[17:29:46.864]                       inherits <- base::inherits
[17:29:46.864]                       invokeRestart <- base::invokeRestart
[17:29:46.864]                       is.null <- base::is.null
[17:29:46.864]                       muffled <- FALSE
[17:29:46.864]                       if (inherits(cond, "message")) {
[17:29:46.864]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.864]                         if (muffled) 
[17:29:46.864]                           invokeRestart("muffleMessage")
[17:29:46.864]                       }
[17:29:46.864]                       else if (inherits(cond, "warning")) {
[17:29:46.864]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.864]                         if (muffled) 
[17:29:46.864]                           invokeRestart("muffleWarning")
[17:29:46.864]                       }
[17:29:46.864]                       else if (inherits(cond, "condition")) {
[17:29:46.864]                         if (!is.null(pattern)) {
[17:29:46.864]                           computeRestarts <- base::computeRestarts
[17:29:46.864]                           grepl <- base::grepl
[17:29:46.864]                           restarts <- computeRestarts(cond)
[17:29:46.864]                           for (restart in restarts) {
[17:29:46.864]                             name <- restart$name
[17:29:46.864]                             if (is.null(name)) 
[17:29:46.864]                               next
[17:29:46.864]                             if (!grepl(pattern, name)) 
[17:29:46.864]                               next
[17:29:46.864]                             invokeRestart(restart)
[17:29:46.864]                             muffled <- TRUE
[17:29:46.864]                             break
[17:29:46.864]                           }
[17:29:46.864]                         }
[17:29:46.864]                       }
[17:29:46.864]                       invisible(muffled)
[17:29:46.864]                     }
[17:29:46.864]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.864]                   }
[17:29:46.864]                 }
[17:29:46.864]                 else {
[17:29:46.864]                   if (TRUE) {
[17:29:46.864]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.864]                     {
[17:29:46.864]                       inherits <- base::inherits
[17:29:46.864]                       invokeRestart <- base::invokeRestart
[17:29:46.864]                       is.null <- base::is.null
[17:29:46.864]                       muffled <- FALSE
[17:29:46.864]                       if (inherits(cond, "message")) {
[17:29:46.864]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.864]                         if (muffled) 
[17:29:46.864]                           invokeRestart("muffleMessage")
[17:29:46.864]                       }
[17:29:46.864]                       else if (inherits(cond, "warning")) {
[17:29:46.864]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.864]                         if (muffled) 
[17:29:46.864]                           invokeRestart("muffleWarning")
[17:29:46.864]                       }
[17:29:46.864]                       else if (inherits(cond, "condition")) {
[17:29:46.864]                         if (!is.null(pattern)) {
[17:29:46.864]                           computeRestarts <- base::computeRestarts
[17:29:46.864]                           grepl <- base::grepl
[17:29:46.864]                           restarts <- computeRestarts(cond)
[17:29:46.864]                           for (restart in restarts) {
[17:29:46.864]                             name <- restart$name
[17:29:46.864]                             if (is.null(name)) 
[17:29:46.864]                               next
[17:29:46.864]                             if (!grepl(pattern, name)) 
[17:29:46.864]                               next
[17:29:46.864]                             invokeRestart(restart)
[17:29:46.864]                             muffled <- TRUE
[17:29:46.864]                             break
[17:29:46.864]                           }
[17:29:46.864]                         }
[17:29:46.864]                       }
[17:29:46.864]                       invisible(muffled)
[17:29:46.864]                     }
[17:29:46.864]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.864]                   }
[17:29:46.864]                 }
[17:29:46.864]             }
[17:29:46.864]         }))
[17:29:46.864]     }, error = function(ex) {
[17:29:46.864]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:46.864]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.864]                 ...future.rng), started = ...future.startTime, 
[17:29:46.864]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:46.864]             version = "1.8"), class = "FutureResult")
[17:29:46.864]     }, finally = {
[17:29:46.864]         if (!identical(...future.workdir, getwd())) 
[17:29:46.864]             setwd(...future.workdir)
[17:29:46.864]         {
[17:29:46.864]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:46.864]                 ...future.oldOptions$nwarnings <- NULL
[17:29:46.864]             }
[17:29:46.864]             base::options(...future.oldOptions)
[17:29:46.864]             if (.Platform$OS.type == "windows") {
[17:29:46.864]                 old_names <- names(...future.oldEnvVars)
[17:29:46.864]                 envs <- base::Sys.getenv()
[17:29:46.864]                 names <- names(envs)
[17:29:46.864]                 common <- intersect(names, old_names)
[17:29:46.864]                 added <- setdiff(names, old_names)
[17:29:46.864]                 removed <- setdiff(old_names, names)
[17:29:46.864]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:46.864]                   envs[common]]
[17:29:46.864]                 NAMES <- toupper(changed)
[17:29:46.864]                 args <- list()
[17:29:46.864]                 for (kk in seq_along(NAMES)) {
[17:29:46.864]                   name <- changed[[kk]]
[17:29:46.864]                   NAME <- NAMES[[kk]]
[17:29:46.864]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.864]                     next
[17:29:46.864]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.864]                 }
[17:29:46.864]                 NAMES <- toupper(added)
[17:29:46.864]                 for (kk in seq_along(NAMES)) {
[17:29:46.864]                   name <- added[[kk]]
[17:29:46.864]                   NAME <- NAMES[[kk]]
[17:29:46.864]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.864]                     next
[17:29:46.864]                   args[[name]] <- ""
[17:29:46.864]                 }
[17:29:46.864]                 NAMES <- toupper(removed)
[17:29:46.864]                 for (kk in seq_along(NAMES)) {
[17:29:46.864]                   name <- removed[[kk]]
[17:29:46.864]                   NAME <- NAMES[[kk]]
[17:29:46.864]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.864]                     next
[17:29:46.864]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.864]                 }
[17:29:46.864]                 if (length(args) > 0) 
[17:29:46.864]                   base::do.call(base::Sys.setenv, args = args)
[17:29:46.864]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:46.864]             }
[17:29:46.864]             else {
[17:29:46.864]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:46.864]             }
[17:29:46.864]             {
[17:29:46.864]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:46.864]                   0L) {
[17:29:46.864]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:46.864]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:46.864]                   base::options(opts)
[17:29:46.864]                 }
[17:29:46.864]                 {
[17:29:46.864]                   {
[17:29:46.864]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:46.864]                     NULL
[17:29:46.864]                   }
[17:29:46.864]                   options(future.plan = NULL)
[17:29:46.864]                   if (is.na(NA_character_)) 
[17:29:46.864]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.864]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:46.864]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:46.864]                     .init = FALSE)
[17:29:46.864]                 }
[17:29:46.864]             }
[17:29:46.864]         }
[17:29:46.864]     })
[17:29:46.864]     if (TRUE) {
[17:29:46.864]         base::sink(type = "output", split = FALSE)
[17:29:46.864]         if (TRUE) {
[17:29:46.864]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:46.864]         }
[17:29:46.864]         else {
[17:29:46.864]             ...future.result["stdout"] <- base::list(NULL)
[17:29:46.864]         }
[17:29:46.864]         base::close(...future.stdout)
[17:29:46.864]         ...future.stdout <- NULL
[17:29:46.864]     }
[17:29:46.864]     ...future.result$conditions <- ...future.conditions
[17:29:46.864]     ...future.result$finished <- base::Sys.time()
[17:29:46.864]     ...future.result
[17:29:46.864] }
[17:29:46.869] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:46.870] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:46.870] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:46.870] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:46.871] MultisessionFuture started
[17:29:46.871] - Launch lazy future ... done
[17:29:46.871] run() for 'MultisessionFuture' ... done
[17:29:46.872] getGlobalsAndPackages() ...
[17:29:46.872] Searching for globals...
[17:29:46.873] - globals found: [3] '{', 'sample', 'x'
[17:29:46.874] Searching for globals ... DONE
[17:29:46.874] Resolving globals: FALSE
[17:29:46.874] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:46.875] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:46.875] - globals: [1] 'x'
[17:29:46.875] 
[17:29:46.875] getGlobalsAndPackages() ... DONE
[17:29:46.876] run() for 'Future' ...
[17:29:46.876] - state: 'created'
[17:29:46.876] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:46.892] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.892] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:46.893]   - Field: 'node'
[17:29:46.893]   - Field: 'label'
[17:29:46.893]   - Field: 'local'
[17:29:46.893]   - Field: 'owner'
[17:29:46.893]   - Field: 'envir'
[17:29:46.894]   - Field: 'workers'
[17:29:46.894]   - Field: 'packages'
[17:29:46.894]   - Field: 'gc'
[17:29:46.894]   - Field: 'conditions'
[17:29:46.895]   - Field: 'persistent'
[17:29:46.895]   - Field: 'expr'
[17:29:46.895]   - Field: 'uuid'
[17:29:46.895]   - Field: 'seed'
[17:29:46.896]   - Field: 'version'
[17:29:46.896]   - Field: 'result'
[17:29:46.896]   - Field: 'asynchronous'
[17:29:46.897]   - Field: 'calls'
[17:29:46.897]   - Field: 'globals'
[17:29:46.897]   - Field: 'stdout'
[17:29:46.897]   - Field: 'earlySignal'
[17:29:46.898]   - Field: 'lazy'
[17:29:46.898]   - Field: 'state'
[17:29:46.898] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:46.898] - Launch lazy future ...
[17:29:46.899] Packages needed by the future expression (n = 0): <none>
[17:29:46.899] Packages needed by future strategies (n = 0): <none>
[17:29:46.900] {
[17:29:46.900]     {
[17:29:46.900]         {
[17:29:46.900]             ...future.startTime <- base::Sys.time()
[17:29:46.900]             {
[17:29:46.900]                 {
[17:29:46.900]                   {
[17:29:46.900]                     {
[17:29:46.900]                       {
[17:29:46.900]                         base::local({
[17:29:46.900]                           has_future <- base::requireNamespace("future", 
[17:29:46.900]                             quietly = TRUE)
[17:29:46.900]                           if (has_future) {
[17:29:46.900]                             ns <- base::getNamespace("future")
[17:29:46.900]                             version <- ns[[".package"]][["version"]]
[17:29:46.900]                             if (is.null(version)) 
[17:29:46.900]                               version <- utils::packageVersion("future")
[17:29:46.900]                           }
[17:29:46.900]                           else {
[17:29:46.900]                             version <- NULL
[17:29:46.900]                           }
[17:29:46.900]                           if (!has_future || version < "1.8.0") {
[17:29:46.900]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:46.900]                               "", base::R.version$version.string), 
[17:29:46.900]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:46.900]                                 base::R.version$platform, 8 * 
[17:29:46.900]                                   base::.Machine$sizeof.pointer), 
[17:29:46.900]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:46.900]                                 "release", "version")], collapse = " "), 
[17:29:46.900]                               hostname = base::Sys.info()[["nodename"]])
[17:29:46.900]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:46.900]                               info)
[17:29:46.900]                             info <- base::paste(info, collapse = "; ")
[17:29:46.900]                             if (!has_future) {
[17:29:46.900]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:46.900]                                 info)
[17:29:46.900]                             }
[17:29:46.900]                             else {
[17:29:46.900]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:46.900]                                 info, version)
[17:29:46.900]                             }
[17:29:46.900]                             base::stop(msg)
[17:29:46.900]                           }
[17:29:46.900]                         })
[17:29:46.900]                       }
[17:29:46.900]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:46.900]                       base::options(mc.cores = 1L)
[17:29:46.900]                     }
[17:29:46.900]                     ...future.strategy.old <- future::plan("list")
[17:29:46.900]                     options(future.plan = NULL)
[17:29:46.900]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.900]                     future::plan("default", .cleanup = FALSE, 
[17:29:46.900]                       .init = FALSE)
[17:29:46.900]                   }
[17:29:46.900]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[17:29:46.900]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[17:29:46.900]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[17:29:46.900]                 }
[17:29:46.900]                 ...future.workdir <- getwd()
[17:29:46.900]             }
[17:29:46.900]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:46.900]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:46.900]         }
[17:29:46.900]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:46.900]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:46.900]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:46.900]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:46.900]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:46.900]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:46.900]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:46.900]             base::names(...future.oldOptions))
[17:29:46.900]     }
[17:29:46.900]     if (FALSE) {
[17:29:46.900]     }
[17:29:46.900]     else {
[17:29:46.900]         if (TRUE) {
[17:29:46.900]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:46.900]                 open = "w")
[17:29:46.900]         }
[17:29:46.900]         else {
[17:29:46.900]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:46.900]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:46.900]         }
[17:29:46.900]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:46.900]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:46.900]             base::sink(type = "output", split = FALSE)
[17:29:46.900]             base::close(...future.stdout)
[17:29:46.900]         }, add = TRUE)
[17:29:46.900]     }
[17:29:46.900]     ...future.frame <- base::sys.nframe()
[17:29:46.900]     ...future.conditions <- base::list()
[17:29:46.900]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:46.900]     if (FALSE) {
[17:29:46.900]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:46.900]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:46.900]     }
[17:29:46.900]     ...future.result <- base::tryCatch({
[17:29:46.900]         base::withCallingHandlers({
[17:29:46.900]             ...future.value <- base::withVisible(base::local({
[17:29:46.900]                 ...future.makeSendCondition <- base::local({
[17:29:46.900]                   sendCondition <- NULL
[17:29:46.900]                   function(frame = 1L) {
[17:29:46.900]                     if (is.function(sendCondition)) 
[17:29:46.900]                       return(sendCondition)
[17:29:46.900]                     ns <- getNamespace("parallel")
[17:29:46.900]                     if (exists("sendData", mode = "function", 
[17:29:46.900]                       envir = ns)) {
[17:29:46.900]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:46.900]                         envir = ns)
[17:29:46.900]                       envir <- sys.frame(frame)
[17:29:46.900]                       master <- NULL
[17:29:46.900]                       while (!identical(envir, .GlobalEnv) && 
[17:29:46.900]                         !identical(envir, emptyenv())) {
[17:29:46.900]                         if (exists("master", mode = "list", envir = envir, 
[17:29:46.900]                           inherits = FALSE)) {
[17:29:46.900]                           master <- get("master", mode = "list", 
[17:29:46.900]                             envir = envir, inherits = FALSE)
[17:29:46.900]                           if (inherits(master, c("SOCKnode", 
[17:29:46.900]                             "SOCK0node"))) {
[17:29:46.900]                             sendCondition <<- function(cond) {
[17:29:46.900]                               data <- list(type = "VALUE", value = cond, 
[17:29:46.900]                                 success = TRUE)
[17:29:46.900]                               parallel_sendData(master, data)
[17:29:46.900]                             }
[17:29:46.900]                             return(sendCondition)
[17:29:46.900]                           }
[17:29:46.900]                         }
[17:29:46.900]                         frame <- frame + 1L
[17:29:46.900]                         envir <- sys.frame(frame)
[17:29:46.900]                       }
[17:29:46.900]                     }
[17:29:46.900]                     sendCondition <<- function(cond) NULL
[17:29:46.900]                   }
[17:29:46.900]                 })
[17:29:46.900]                 withCallingHandlers({
[17:29:46.900]                   {
[17:29:46.900]                     sample(x, size = 1L)
[17:29:46.900]                   }
[17:29:46.900]                 }, immediateCondition = function(cond) {
[17:29:46.900]                   sendCondition <- ...future.makeSendCondition()
[17:29:46.900]                   sendCondition(cond)
[17:29:46.900]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.900]                   {
[17:29:46.900]                     inherits <- base::inherits
[17:29:46.900]                     invokeRestart <- base::invokeRestart
[17:29:46.900]                     is.null <- base::is.null
[17:29:46.900]                     muffled <- FALSE
[17:29:46.900]                     if (inherits(cond, "message")) {
[17:29:46.900]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:46.900]                       if (muffled) 
[17:29:46.900]                         invokeRestart("muffleMessage")
[17:29:46.900]                     }
[17:29:46.900]                     else if (inherits(cond, "warning")) {
[17:29:46.900]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:46.900]                       if (muffled) 
[17:29:46.900]                         invokeRestart("muffleWarning")
[17:29:46.900]                     }
[17:29:46.900]                     else if (inherits(cond, "condition")) {
[17:29:46.900]                       if (!is.null(pattern)) {
[17:29:46.900]                         computeRestarts <- base::computeRestarts
[17:29:46.900]                         grepl <- base::grepl
[17:29:46.900]                         restarts <- computeRestarts(cond)
[17:29:46.900]                         for (restart in restarts) {
[17:29:46.900]                           name <- restart$name
[17:29:46.900]                           if (is.null(name)) 
[17:29:46.900]                             next
[17:29:46.900]                           if (!grepl(pattern, name)) 
[17:29:46.900]                             next
[17:29:46.900]                           invokeRestart(restart)
[17:29:46.900]                           muffled <- TRUE
[17:29:46.900]                           break
[17:29:46.900]                         }
[17:29:46.900]                       }
[17:29:46.900]                     }
[17:29:46.900]                     invisible(muffled)
[17:29:46.900]                   }
[17:29:46.900]                   muffleCondition(cond)
[17:29:46.900]                 })
[17:29:46.900]             }))
[17:29:46.900]             future::FutureResult(value = ...future.value$value, 
[17:29:46.900]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.900]                   ...future.rng), globalenv = if (FALSE) 
[17:29:46.900]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:46.900]                     ...future.globalenv.names))
[17:29:46.900]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:46.900]         }, condition = base::local({
[17:29:46.900]             c <- base::c
[17:29:46.900]             inherits <- base::inherits
[17:29:46.900]             invokeRestart <- base::invokeRestart
[17:29:46.900]             length <- base::length
[17:29:46.900]             list <- base::list
[17:29:46.900]             seq.int <- base::seq.int
[17:29:46.900]             signalCondition <- base::signalCondition
[17:29:46.900]             sys.calls <- base::sys.calls
[17:29:46.900]             `[[` <- base::`[[`
[17:29:46.900]             `+` <- base::`+`
[17:29:46.900]             `<<-` <- base::`<<-`
[17:29:46.900]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:46.900]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:46.900]                   3L)]
[17:29:46.900]             }
[17:29:46.900]             function(cond) {
[17:29:46.900]                 is_error <- inherits(cond, "error")
[17:29:46.900]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:46.900]                   NULL)
[17:29:46.900]                 if (is_error) {
[17:29:46.900]                   sessionInformation <- function() {
[17:29:46.900]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:46.900]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:46.900]                       search = base::search(), system = base::Sys.info())
[17:29:46.900]                   }
[17:29:46.900]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.900]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:46.900]                     cond$call), session = sessionInformation(), 
[17:29:46.900]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:46.900]                   signalCondition(cond)
[17:29:46.900]                 }
[17:29:46.900]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:46.900]                 "immediateCondition"))) {
[17:29:46.900]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:46.900]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.900]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:46.900]                   if (TRUE && !signal) {
[17:29:46.900]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.900]                     {
[17:29:46.900]                       inherits <- base::inherits
[17:29:46.900]                       invokeRestart <- base::invokeRestart
[17:29:46.900]                       is.null <- base::is.null
[17:29:46.900]                       muffled <- FALSE
[17:29:46.900]                       if (inherits(cond, "message")) {
[17:29:46.900]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.900]                         if (muffled) 
[17:29:46.900]                           invokeRestart("muffleMessage")
[17:29:46.900]                       }
[17:29:46.900]                       else if (inherits(cond, "warning")) {
[17:29:46.900]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.900]                         if (muffled) 
[17:29:46.900]                           invokeRestart("muffleWarning")
[17:29:46.900]                       }
[17:29:46.900]                       else if (inherits(cond, "condition")) {
[17:29:46.900]                         if (!is.null(pattern)) {
[17:29:46.900]                           computeRestarts <- base::computeRestarts
[17:29:46.900]                           grepl <- base::grepl
[17:29:46.900]                           restarts <- computeRestarts(cond)
[17:29:46.900]                           for (restart in restarts) {
[17:29:46.900]                             name <- restart$name
[17:29:46.900]                             if (is.null(name)) 
[17:29:46.900]                               next
[17:29:46.900]                             if (!grepl(pattern, name)) 
[17:29:46.900]                               next
[17:29:46.900]                             invokeRestart(restart)
[17:29:46.900]                             muffled <- TRUE
[17:29:46.900]                             break
[17:29:46.900]                           }
[17:29:46.900]                         }
[17:29:46.900]                       }
[17:29:46.900]                       invisible(muffled)
[17:29:46.900]                     }
[17:29:46.900]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.900]                   }
[17:29:46.900]                 }
[17:29:46.900]                 else {
[17:29:46.900]                   if (TRUE) {
[17:29:46.900]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.900]                     {
[17:29:46.900]                       inherits <- base::inherits
[17:29:46.900]                       invokeRestart <- base::invokeRestart
[17:29:46.900]                       is.null <- base::is.null
[17:29:46.900]                       muffled <- FALSE
[17:29:46.900]                       if (inherits(cond, "message")) {
[17:29:46.900]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.900]                         if (muffled) 
[17:29:46.900]                           invokeRestart("muffleMessage")
[17:29:46.900]                       }
[17:29:46.900]                       else if (inherits(cond, "warning")) {
[17:29:46.900]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.900]                         if (muffled) 
[17:29:46.900]                           invokeRestart("muffleWarning")
[17:29:46.900]                       }
[17:29:46.900]                       else if (inherits(cond, "condition")) {
[17:29:46.900]                         if (!is.null(pattern)) {
[17:29:46.900]                           computeRestarts <- base::computeRestarts
[17:29:46.900]                           grepl <- base::grepl
[17:29:46.900]                           restarts <- computeRestarts(cond)
[17:29:46.900]                           for (restart in restarts) {
[17:29:46.900]                             name <- restart$name
[17:29:46.900]                             if (is.null(name)) 
[17:29:46.900]                               next
[17:29:46.900]                             if (!grepl(pattern, name)) 
[17:29:46.900]                               next
[17:29:46.900]                             invokeRestart(restart)
[17:29:46.900]                             muffled <- TRUE
[17:29:46.900]                             break
[17:29:46.900]                           }
[17:29:46.900]                         }
[17:29:46.900]                       }
[17:29:46.900]                       invisible(muffled)
[17:29:46.900]                     }
[17:29:46.900]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.900]                   }
[17:29:46.900]                 }
[17:29:46.900]             }
[17:29:46.900]         }))
[17:29:46.900]     }, error = function(ex) {
[17:29:46.900]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:46.900]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.900]                 ...future.rng), started = ...future.startTime, 
[17:29:46.900]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:46.900]             version = "1.8"), class = "FutureResult")
[17:29:46.900]     }, finally = {
[17:29:46.900]         if (!identical(...future.workdir, getwd())) 
[17:29:46.900]             setwd(...future.workdir)
[17:29:46.900]         {
[17:29:46.900]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:46.900]                 ...future.oldOptions$nwarnings <- NULL
[17:29:46.900]             }
[17:29:46.900]             base::options(...future.oldOptions)
[17:29:46.900]             if (.Platform$OS.type == "windows") {
[17:29:46.900]                 old_names <- names(...future.oldEnvVars)
[17:29:46.900]                 envs <- base::Sys.getenv()
[17:29:46.900]                 names <- names(envs)
[17:29:46.900]                 common <- intersect(names, old_names)
[17:29:46.900]                 added <- setdiff(names, old_names)
[17:29:46.900]                 removed <- setdiff(old_names, names)
[17:29:46.900]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:46.900]                   envs[common]]
[17:29:46.900]                 NAMES <- toupper(changed)
[17:29:46.900]                 args <- list()
[17:29:46.900]                 for (kk in seq_along(NAMES)) {
[17:29:46.900]                   name <- changed[[kk]]
[17:29:46.900]                   NAME <- NAMES[[kk]]
[17:29:46.900]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.900]                     next
[17:29:46.900]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.900]                 }
[17:29:46.900]                 NAMES <- toupper(added)
[17:29:46.900]                 for (kk in seq_along(NAMES)) {
[17:29:46.900]                   name <- added[[kk]]
[17:29:46.900]                   NAME <- NAMES[[kk]]
[17:29:46.900]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.900]                     next
[17:29:46.900]                   args[[name]] <- ""
[17:29:46.900]                 }
[17:29:46.900]                 NAMES <- toupper(removed)
[17:29:46.900]                 for (kk in seq_along(NAMES)) {
[17:29:46.900]                   name <- removed[[kk]]
[17:29:46.900]                   NAME <- NAMES[[kk]]
[17:29:46.900]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.900]                     next
[17:29:46.900]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.900]                 }
[17:29:46.900]                 if (length(args) > 0) 
[17:29:46.900]                   base::do.call(base::Sys.setenv, args = args)
[17:29:46.900]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:46.900]             }
[17:29:46.900]             else {
[17:29:46.900]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:46.900]             }
[17:29:46.900]             {
[17:29:46.900]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:46.900]                   0L) {
[17:29:46.900]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:46.900]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:46.900]                   base::options(opts)
[17:29:46.900]                 }
[17:29:46.900]                 {
[17:29:46.900]                   {
[17:29:46.900]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:46.900]                     NULL
[17:29:46.900]                   }
[17:29:46.900]                   options(future.plan = NULL)
[17:29:46.900]                   if (is.na(NA_character_)) 
[17:29:46.900]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.900]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:46.900]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:46.900]                     .init = FALSE)
[17:29:46.900]                 }
[17:29:46.900]             }
[17:29:46.900]         }
[17:29:46.900]     })
[17:29:46.900]     if (TRUE) {
[17:29:46.900]         base::sink(type = "output", split = FALSE)
[17:29:46.900]         if (TRUE) {
[17:29:46.900]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:46.900]         }
[17:29:46.900]         else {
[17:29:46.900]             ...future.result["stdout"] <- base::list(NULL)
[17:29:46.900]         }
[17:29:46.900]         base::close(...future.stdout)
[17:29:46.900]         ...future.stdout <- NULL
[17:29:46.900]     }
[17:29:46.900]     ...future.result$conditions <- ...future.conditions
[17:29:46.900]     ...future.result$finished <- base::Sys.time()
[17:29:46.900]     ...future.result
[17:29:46.900] }
[17:29:46.909] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:46.909] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:46.910] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:46.910] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:46.911] MultisessionFuture started
[17:29:46.912] - Launch lazy future ... done
[17:29:46.912] run() for 'MultisessionFuture' ... done
[17:29:46.913] getGlobalsAndPackages() ...
[17:29:46.913] Searching for globals...
[17:29:46.915] - globals found: [3] '{', 'sample', 'x'
[17:29:46.916] Searching for globals ... DONE
[17:29:46.916] Resolving globals: FALSE
[17:29:46.917] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:46.918] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:46.918] - globals: [1] 'x'
[17:29:46.918] 
[17:29:46.918] getGlobalsAndPackages() ... DONE
[17:29:46.919] run() for 'Future' ...
[17:29:46.919] - state: 'created'
[17:29:46.920] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:46.941] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:46.942] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:46.942]   - Field: 'node'
[17:29:46.943]   - Field: 'label'
[17:29:46.943]   - Field: 'local'
[17:29:46.944]   - Field: 'owner'
[17:29:46.944]   - Field: 'envir'
[17:29:46.944]   - Field: 'workers'
[17:29:46.945]   - Field: 'packages'
[17:29:46.945]   - Field: 'gc'
[17:29:46.946]   - Field: 'conditions'
[17:29:46.946]   - Field: 'persistent'
[17:29:46.946]   - Field: 'expr'
[17:29:46.947]   - Field: 'uuid'
[17:29:46.947]   - Field: 'seed'
[17:29:46.947]   - Field: 'version'
[17:29:46.948]   - Field: 'result'
[17:29:46.948]   - Field: 'asynchronous'
[17:29:46.949]   - Field: 'calls'
[17:29:46.949]   - Field: 'globals'
[17:29:46.949]   - Field: 'stdout'
[17:29:46.950]   - Field: 'earlySignal'
[17:29:46.950]   - Field: 'lazy'
[17:29:46.950]   - Field: 'state'
[17:29:46.951] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:46.951] - Launch lazy future ...
[17:29:46.952] Packages needed by the future expression (n = 0): <none>
[17:29:46.952] Packages needed by future strategies (n = 0): <none>
[17:29:46.954] {
[17:29:46.954]     {
[17:29:46.954]         {
[17:29:46.954]             ...future.startTime <- base::Sys.time()
[17:29:46.954]             {
[17:29:46.954]                 {
[17:29:46.954]                   {
[17:29:46.954]                     {
[17:29:46.954]                       {
[17:29:46.954]                         base::local({
[17:29:46.954]                           has_future <- base::requireNamespace("future", 
[17:29:46.954]                             quietly = TRUE)
[17:29:46.954]                           if (has_future) {
[17:29:46.954]                             ns <- base::getNamespace("future")
[17:29:46.954]                             version <- ns[[".package"]][["version"]]
[17:29:46.954]                             if (is.null(version)) 
[17:29:46.954]                               version <- utils::packageVersion("future")
[17:29:46.954]                           }
[17:29:46.954]                           else {
[17:29:46.954]                             version <- NULL
[17:29:46.954]                           }
[17:29:46.954]                           if (!has_future || version < "1.8.0") {
[17:29:46.954]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:46.954]                               "", base::R.version$version.string), 
[17:29:46.954]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:46.954]                                 base::R.version$platform, 8 * 
[17:29:46.954]                                   base::.Machine$sizeof.pointer), 
[17:29:46.954]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:46.954]                                 "release", "version")], collapse = " "), 
[17:29:46.954]                               hostname = base::Sys.info()[["nodename"]])
[17:29:46.954]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:46.954]                               info)
[17:29:46.954]                             info <- base::paste(info, collapse = "; ")
[17:29:46.954]                             if (!has_future) {
[17:29:46.954]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:46.954]                                 info)
[17:29:46.954]                             }
[17:29:46.954]                             else {
[17:29:46.954]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:46.954]                                 info, version)
[17:29:46.954]                             }
[17:29:46.954]                             base::stop(msg)
[17:29:46.954]                           }
[17:29:46.954]                         })
[17:29:46.954]                       }
[17:29:46.954]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:46.954]                       base::options(mc.cores = 1L)
[17:29:46.954]                     }
[17:29:46.954]                     ...future.strategy.old <- future::plan("list")
[17:29:46.954]                     options(future.plan = NULL)
[17:29:46.954]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.954]                     future::plan("default", .cleanup = FALSE, 
[17:29:46.954]                       .init = FALSE)
[17:29:46.954]                   }
[17:29:46.954]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[17:29:46.954]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[17:29:46.954]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[17:29:46.954]                 }
[17:29:46.954]                 ...future.workdir <- getwd()
[17:29:46.954]             }
[17:29:46.954]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:46.954]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:46.954]         }
[17:29:46.954]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:46.954]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:46.954]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:46.954]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:46.954]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:46.954]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:46.954]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:46.954]             base::names(...future.oldOptions))
[17:29:46.954]     }
[17:29:46.954]     if (FALSE) {
[17:29:46.954]     }
[17:29:46.954]     else {
[17:29:46.954]         if (TRUE) {
[17:29:46.954]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:46.954]                 open = "w")
[17:29:46.954]         }
[17:29:46.954]         else {
[17:29:46.954]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:46.954]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:46.954]         }
[17:29:46.954]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:46.954]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:46.954]             base::sink(type = "output", split = FALSE)
[17:29:46.954]             base::close(...future.stdout)
[17:29:46.954]         }, add = TRUE)
[17:29:46.954]     }
[17:29:46.954]     ...future.frame <- base::sys.nframe()
[17:29:46.954]     ...future.conditions <- base::list()
[17:29:46.954]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:46.954]     if (FALSE) {
[17:29:46.954]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:46.954]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:46.954]     }
[17:29:46.954]     ...future.result <- base::tryCatch({
[17:29:46.954]         base::withCallingHandlers({
[17:29:46.954]             ...future.value <- base::withVisible(base::local({
[17:29:46.954]                 ...future.makeSendCondition <- base::local({
[17:29:46.954]                   sendCondition <- NULL
[17:29:46.954]                   function(frame = 1L) {
[17:29:46.954]                     if (is.function(sendCondition)) 
[17:29:46.954]                       return(sendCondition)
[17:29:46.954]                     ns <- getNamespace("parallel")
[17:29:46.954]                     if (exists("sendData", mode = "function", 
[17:29:46.954]                       envir = ns)) {
[17:29:46.954]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:46.954]                         envir = ns)
[17:29:46.954]                       envir <- sys.frame(frame)
[17:29:46.954]                       master <- NULL
[17:29:46.954]                       while (!identical(envir, .GlobalEnv) && 
[17:29:46.954]                         !identical(envir, emptyenv())) {
[17:29:46.954]                         if (exists("master", mode = "list", envir = envir, 
[17:29:46.954]                           inherits = FALSE)) {
[17:29:46.954]                           master <- get("master", mode = "list", 
[17:29:46.954]                             envir = envir, inherits = FALSE)
[17:29:46.954]                           if (inherits(master, c("SOCKnode", 
[17:29:46.954]                             "SOCK0node"))) {
[17:29:46.954]                             sendCondition <<- function(cond) {
[17:29:46.954]                               data <- list(type = "VALUE", value = cond, 
[17:29:46.954]                                 success = TRUE)
[17:29:46.954]                               parallel_sendData(master, data)
[17:29:46.954]                             }
[17:29:46.954]                             return(sendCondition)
[17:29:46.954]                           }
[17:29:46.954]                         }
[17:29:46.954]                         frame <- frame + 1L
[17:29:46.954]                         envir <- sys.frame(frame)
[17:29:46.954]                       }
[17:29:46.954]                     }
[17:29:46.954]                     sendCondition <<- function(cond) NULL
[17:29:46.954]                   }
[17:29:46.954]                 })
[17:29:46.954]                 withCallingHandlers({
[17:29:46.954]                   {
[17:29:46.954]                     sample(x, size = 1L)
[17:29:46.954]                   }
[17:29:46.954]                 }, immediateCondition = function(cond) {
[17:29:46.954]                   sendCondition <- ...future.makeSendCondition()
[17:29:46.954]                   sendCondition(cond)
[17:29:46.954]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.954]                   {
[17:29:46.954]                     inherits <- base::inherits
[17:29:46.954]                     invokeRestart <- base::invokeRestart
[17:29:46.954]                     is.null <- base::is.null
[17:29:46.954]                     muffled <- FALSE
[17:29:46.954]                     if (inherits(cond, "message")) {
[17:29:46.954]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:46.954]                       if (muffled) 
[17:29:46.954]                         invokeRestart("muffleMessage")
[17:29:46.954]                     }
[17:29:46.954]                     else if (inherits(cond, "warning")) {
[17:29:46.954]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:46.954]                       if (muffled) 
[17:29:46.954]                         invokeRestart("muffleWarning")
[17:29:46.954]                     }
[17:29:46.954]                     else if (inherits(cond, "condition")) {
[17:29:46.954]                       if (!is.null(pattern)) {
[17:29:46.954]                         computeRestarts <- base::computeRestarts
[17:29:46.954]                         grepl <- base::grepl
[17:29:46.954]                         restarts <- computeRestarts(cond)
[17:29:46.954]                         for (restart in restarts) {
[17:29:46.954]                           name <- restart$name
[17:29:46.954]                           if (is.null(name)) 
[17:29:46.954]                             next
[17:29:46.954]                           if (!grepl(pattern, name)) 
[17:29:46.954]                             next
[17:29:46.954]                           invokeRestart(restart)
[17:29:46.954]                           muffled <- TRUE
[17:29:46.954]                           break
[17:29:46.954]                         }
[17:29:46.954]                       }
[17:29:46.954]                     }
[17:29:46.954]                     invisible(muffled)
[17:29:46.954]                   }
[17:29:46.954]                   muffleCondition(cond)
[17:29:46.954]                 })
[17:29:46.954]             }))
[17:29:46.954]             future::FutureResult(value = ...future.value$value, 
[17:29:46.954]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.954]                   ...future.rng), globalenv = if (FALSE) 
[17:29:46.954]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:46.954]                     ...future.globalenv.names))
[17:29:46.954]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:46.954]         }, condition = base::local({
[17:29:46.954]             c <- base::c
[17:29:46.954]             inherits <- base::inherits
[17:29:46.954]             invokeRestart <- base::invokeRestart
[17:29:46.954]             length <- base::length
[17:29:46.954]             list <- base::list
[17:29:46.954]             seq.int <- base::seq.int
[17:29:46.954]             signalCondition <- base::signalCondition
[17:29:46.954]             sys.calls <- base::sys.calls
[17:29:46.954]             `[[` <- base::`[[`
[17:29:46.954]             `+` <- base::`+`
[17:29:46.954]             `<<-` <- base::`<<-`
[17:29:46.954]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:46.954]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:46.954]                   3L)]
[17:29:46.954]             }
[17:29:46.954]             function(cond) {
[17:29:46.954]                 is_error <- inherits(cond, "error")
[17:29:46.954]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:46.954]                   NULL)
[17:29:46.954]                 if (is_error) {
[17:29:46.954]                   sessionInformation <- function() {
[17:29:46.954]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:46.954]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:46.954]                       search = base::search(), system = base::Sys.info())
[17:29:46.954]                   }
[17:29:46.954]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.954]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:46.954]                     cond$call), session = sessionInformation(), 
[17:29:46.954]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:46.954]                   signalCondition(cond)
[17:29:46.954]                 }
[17:29:46.954]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:46.954]                 "immediateCondition"))) {
[17:29:46.954]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:46.954]                   ...future.conditions[[length(...future.conditions) + 
[17:29:46.954]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:46.954]                   if (TRUE && !signal) {
[17:29:46.954]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.954]                     {
[17:29:46.954]                       inherits <- base::inherits
[17:29:46.954]                       invokeRestart <- base::invokeRestart
[17:29:46.954]                       is.null <- base::is.null
[17:29:46.954]                       muffled <- FALSE
[17:29:46.954]                       if (inherits(cond, "message")) {
[17:29:46.954]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.954]                         if (muffled) 
[17:29:46.954]                           invokeRestart("muffleMessage")
[17:29:46.954]                       }
[17:29:46.954]                       else if (inherits(cond, "warning")) {
[17:29:46.954]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.954]                         if (muffled) 
[17:29:46.954]                           invokeRestart("muffleWarning")
[17:29:46.954]                       }
[17:29:46.954]                       else if (inherits(cond, "condition")) {
[17:29:46.954]                         if (!is.null(pattern)) {
[17:29:46.954]                           computeRestarts <- base::computeRestarts
[17:29:46.954]                           grepl <- base::grepl
[17:29:46.954]                           restarts <- computeRestarts(cond)
[17:29:46.954]                           for (restart in restarts) {
[17:29:46.954]                             name <- restart$name
[17:29:46.954]                             if (is.null(name)) 
[17:29:46.954]                               next
[17:29:46.954]                             if (!grepl(pattern, name)) 
[17:29:46.954]                               next
[17:29:46.954]                             invokeRestart(restart)
[17:29:46.954]                             muffled <- TRUE
[17:29:46.954]                             break
[17:29:46.954]                           }
[17:29:46.954]                         }
[17:29:46.954]                       }
[17:29:46.954]                       invisible(muffled)
[17:29:46.954]                     }
[17:29:46.954]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.954]                   }
[17:29:46.954]                 }
[17:29:46.954]                 else {
[17:29:46.954]                   if (TRUE) {
[17:29:46.954]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:46.954]                     {
[17:29:46.954]                       inherits <- base::inherits
[17:29:46.954]                       invokeRestart <- base::invokeRestart
[17:29:46.954]                       is.null <- base::is.null
[17:29:46.954]                       muffled <- FALSE
[17:29:46.954]                       if (inherits(cond, "message")) {
[17:29:46.954]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:46.954]                         if (muffled) 
[17:29:46.954]                           invokeRestart("muffleMessage")
[17:29:46.954]                       }
[17:29:46.954]                       else if (inherits(cond, "warning")) {
[17:29:46.954]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:46.954]                         if (muffled) 
[17:29:46.954]                           invokeRestart("muffleWarning")
[17:29:46.954]                       }
[17:29:46.954]                       else if (inherits(cond, "condition")) {
[17:29:46.954]                         if (!is.null(pattern)) {
[17:29:46.954]                           computeRestarts <- base::computeRestarts
[17:29:46.954]                           grepl <- base::grepl
[17:29:46.954]                           restarts <- computeRestarts(cond)
[17:29:46.954]                           for (restart in restarts) {
[17:29:46.954]                             name <- restart$name
[17:29:46.954]                             if (is.null(name)) 
[17:29:46.954]                               next
[17:29:46.954]                             if (!grepl(pattern, name)) 
[17:29:46.954]                               next
[17:29:46.954]                             invokeRestart(restart)
[17:29:46.954]                             muffled <- TRUE
[17:29:46.954]                             break
[17:29:46.954]                           }
[17:29:46.954]                         }
[17:29:46.954]                       }
[17:29:46.954]                       invisible(muffled)
[17:29:46.954]                     }
[17:29:46.954]                     muffleCondition(cond, pattern = "^muffle")
[17:29:46.954]                   }
[17:29:46.954]                 }
[17:29:46.954]             }
[17:29:46.954]         }))
[17:29:46.954]     }, error = function(ex) {
[17:29:46.954]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:46.954]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:46.954]                 ...future.rng), started = ...future.startTime, 
[17:29:46.954]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:46.954]             version = "1.8"), class = "FutureResult")
[17:29:46.954]     }, finally = {
[17:29:46.954]         if (!identical(...future.workdir, getwd())) 
[17:29:46.954]             setwd(...future.workdir)
[17:29:46.954]         {
[17:29:46.954]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:46.954]                 ...future.oldOptions$nwarnings <- NULL
[17:29:46.954]             }
[17:29:46.954]             base::options(...future.oldOptions)
[17:29:46.954]             if (.Platform$OS.type == "windows") {
[17:29:46.954]                 old_names <- names(...future.oldEnvVars)
[17:29:46.954]                 envs <- base::Sys.getenv()
[17:29:46.954]                 names <- names(envs)
[17:29:46.954]                 common <- intersect(names, old_names)
[17:29:46.954]                 added <- setdiff(names, old_names)
[17:29:46.954]                 removed <- setdiff(old_names, names)
[17:29:46.954]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:46.954]                   envs[common]]
[17:29:46.954]                 NAMES <- toupper(changed)
[17:29:46.954]                 args <- list()
[17:29:46.954]                 for (kk in seq_along(NAMES)) {
[17:29:46.954]                   name <- changed[[kk]]
[17:29:46.954]                   NAME <- NAMES[[kk]]
[17:29:46.954]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.954]                     next
[17:29:46.954]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.954]                 }
[17:29:46.954]                 NAMES <- toupper(added)
[17:29:46.954]                 for (kk in seq_along(NAMES)) {
[17:29:46.954]                   name <- added[[kk]]
[17:29:46.954]                   NAME <- NAMES[[kk]]
[17:29:46.954]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.954]                     next
[17:29:46.954]                   args[[name]] <- ""
[17:29:46.954]                 }
[17:29:46.954]                 NAMES <- toupper(removed)
[17:29:46.954]                 for (kk in seq_along(NAMES)) {
[17:29:46.954]                   name <- removed[[kk]]
[17:29:46.954]                   NAME <- NAMES[[kk]]
[17:29:46.954]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:46.954]                     next
[17:29:46.954]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:46.954]                 }
[17:29:46.954]                 if (length(args) > 0) 
[17:29:46.954]                   base::do.call(base::Sys.setenv, args = args)
[17:29:46.954]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:46.954]             }
[17:29:46.954]             else {
[17:29:46.954]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:46.954]             }
[17:29:46.954]             {
[17:29:46.954]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:46.954]                   0L) {
[17:29:46.954]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:46.954]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:46.954]                   base::options(opts)
[17:29:46.954]                 }
[17:29:46.954]                 {
[17:29:46.954]                   {
[17:29:46.954]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:46.954]                     NULL
[17:29:46.954]                   }
[17:29:46.954]                   options(future.plan = NULL)
[17:29:46.954]                   if (is.na(NA_character_)) 
[17:29:46.954]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:46.954]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:46.954]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:46.954]                     .init = FALSE)
[17:29:46.954]                 }
[17:29:46.954]             }
[17:29:46.954]         }
[17:29:46.954]     })
[17:29:46.954]     if (TRUE) {
[17:29:46.954]         base::sink(type = "output", split = FALSE)
[17:29:46.954]         if (TRUE) {
[17:29:46.954]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:46.954]         }
[17:29:46.954]         else {
[17:29:46.954]             ...future.result["stdout"] <- base::list(NULL)
[17:29:46.954]         }
[17:29:46.954]         base::close(...future.stdout)
[17:29:46.954]         ...future.stdout <- NULL
[17:29:46.954]     }
[17:29:46.954]     ...future.result$conditions <- ...future.conditions
[17:29:46.954]     ...future.result$finished <- base::Sys.time()
[17:29:46.954]     ...future.result
[17:29:46.954] }
[17:29:46.962] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:46.988] receiveMessageFromWorker() for ClusterFuture ...
[17:29:46.989] - Validating connection of MultisessionFuture
[17:29:46.989] - received message: FutureResult
[17:29:46.990] - Received FutureResult
[17:29:46.990] - Erased future from FutureRegistry
[17:29:46.990] result() for ClusterFuture ...
[17:29:46.991] - result already collected: FutureResult
[17:29:46.991] result() for ClusterFuture ... done
[17:29:46.991] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:46.992] result() for ClusterFuture ...
[17:29:46.992] - result already collected: FutureResult
[17:29:46.992] result() for ClusterFuture ... done
[17:29:46.992] result() for ClusterFuture ...
[17:29:46.993] - result already collected: FutureResult
[17:29:46.993] result() for ClusterFuture ... done
[17:29:46.994] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:46.995] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:46.995] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:46.996] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:46.997] MultisessionFuture started
[17:29:46.997] - Launch lazy future ... done
[17:29:46.997] run() for 'MultisessionFuture' ... done
[17:29:46.998] getGlobalsAndPackages() ...
[17:29:46.999] Searching for globals...
[17:29:47.001] - globals found: [3] '{', 'sample', 'x'
[17:29:47.001] Searching for globals ... DONE
[17:29:47.001] Resolving globals: FALSE
[17:29:47.002] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:47.003] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:47.003] - globals: [1] 'x'
[17:29:47.003] 
[17:29:47.004] getGlobalsAndPackages() ... DONE
[17:29:47.004] run() for 'Future' ...
[17:29:47.004] - state: 'created'
[17:29:47.005] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:47.024] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:47.024] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:47.025]   - Field: 'node'
[17:29:47.025]   - Field: 'label'
[17:29:47.025]   - Field: 'local'
[17:29:47.026]   - Field: 'owner'
[17:29:47.026]   - Field: 'envir'
[17:29:47.027]   - Field: 'workers'
[17:29:47.027]   - Field: 'packages'
[17:29:47.027]   - Field: 'gc'
[17:29:47.028]   - Field: 'conditions'
[17:29:47.028]   - Field: 'persistent'
[17:29:47.029]   - Field: 'expr'
[17:29:47.029]   - Field: 'uuid'
[17:29:47.029]   - Field: 'seed'
[17:29:47.030]   - Field: 'version'
[17:29:47.030]   - Field: 'result'
[17:29:47.030]   - Field: 'asynchronous'
[17:29:47.031]   - Field: 'calls'
[17:29:47.031]   - Field: 'globals'
[17:29:47.032]   - Field: 'stdout'
[17:29:47.032]   - Field: 'earlySignal'
[17:29:47.032]   - Field: 'lazy'
[17:29:47.033]   - Field: 'state'
[17:29:47.033] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:47.034] - Launch lazy future ...
[17:29:47.034] Packages needed by the future expression (n = 0): <none>
[17:29:47.035] Packages needed by future strategies (n = 0): <none>
[17:29:47.036] {
[17:29:47.036]     {
[17:29:47.036]         {
[17:29:47.036]             ...future.startTime <- base::Sys.time()
[17:29:47.036]             {
[17:29:47.036]                 {
[17:29:47.036]                   {
[17:29:47.036]                     {
[17:29:47.036]                       {
[17:29:47.036]                         base::local({
[17:29:47.036]                           has_future <- base::requireNamespace("future", 
[17:29:47.036]                             quietly = TRUE)
[17:29:47.036]                           if (has_future) {
[17:29:47.036]                             ns <- base::getNamespace("future")
[17:29:47.036]                             version <- ns[[".package"]][["version"]]
[17:29:47.036]                             if (is.null(version)) 
[17:29:47.036]                               version <- utils::packageVersion("future")
[17:29:47.036]                           }
[17:29:47.036]                           else {
[17:29:47.036]                             version <- NULL
[17:29:47.036]                           }
[17:29:47.036]                           if (!has_future || version < "1.8.0") {
[17:29:47.036]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:47.036]                               "", base::R.version$version.string), 
[17:29:47.036]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:47.036]                                 base::R.version$platform, 8 * 
[17:29:47.036]                                   base::.Machine$sizeof.pointer), 
[17:29:47.036]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:47.036]                                 "release", "version")], collapse = " "), 
[17:29:47.036]                               hostname = base::Sys.info()[["nodename"]])
[17:29:47.036]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:47.036]                               info)
[17:29:47.036]                             info <- base::paste(info, collapse = "; ")
[17:29:47.036]                             if (!has_future) {
[17:29:47.036]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:47.036]                                 info)
[17:29:47.036]                             }
[17:29:47.036]                             else {
[17:29:47.036]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:47.036]                                 info, version)
[17:29:47.036]                             }
[17:29:47.036]                             base::stop(msg)
[17:29:47.036]                           }
[17:29:47.036]                         })
[17:29:47.036]                       }
[17:29:47.036]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:47.036]                       base::options(mc.cores = 1L)
[17:29:47.036]                     }
[17:29:47.036]                     ...future.strategy.old <- future::plan("list")
[17:29:47.036]                     options(future.plan = NULL)
[17:29:47.036]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.036]                     future::plan("default", .cleanup = FALSE, 
[17:29:47.036]                       .init = FALSE)
[17:29:47.036]                   }
[17:29:47.036]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[17:29:47.036]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[17:29:47.036]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[17:29:47.036]                 }
[17:29:47.036]                 ...future.workdir <- getwd()
[17:29:47.036]             }
[17:29:47.036]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:47.036]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:47.036]         }
[17:29:47.036]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:47.036]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:47.036]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:47.036]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:47.036]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:47.036]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:47.036]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:47.036]             base::names(...future.oldOptions))
[17:29:47.036]     }
[17:29:47.036]     if (FALSE) {
[17:29:47.036]     }
[17:29:47.036]     else {
[17:29:47.036]         if (TRUE) {
[17:29:47.036]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:47.036]                 open = "w")
[17:29:47.036]         }
[17:29:47.036]         else {
[17:29:47.036]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:47.036]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:47.036]         }
[17:29:47.036]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:47.036]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:47.036]             base::sink(type = "output", split = FALSE)
[17:29:47.036]             base::close(...future.stdout)
[17:29:47.036]         }, add = TRUE)
[17:29:47.036]     }
[17:29:47.036]     ...future.frame <- base::sys.nframe()
[17:29:47.036]     ...future.conditions <- base::list()
[17:29:47.036]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:47.036]     if (FALSE) {
[17:29:47.036]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:47.036]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:47.036]     }
[17:29:47.036]     ...future.result <- base::tryCatch({
[17:29:47.036]         base::withCallingHandlers({
[17:29:47.036]             ...future.value <- base::withVisible(base::local({
[17:29:47.036]                 ...future.makeSendCondition <- base::local({
[17:29:47.036]                   sendCondition <- NULL
[17:29:47.036]                   function(frame = 1L) {
[17:29:47.036]                     if (is.function(sendCondition)) 
[17:29:47.036]                       return(sendCondition)
[17:29:47.036]                     ns <- getNamespace("parallel")
[17:29:47.036]                     if (exists("sendData", mode = "function", 
[17:29:47.036]                       envir = ns)) {
[17:29:47.036]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:47.036]                         envir = ns)
[17:29:47.036]                       envir <- sys.frame(frame)
[17:29:47.036]                       master <- NULL
[17:29:47.036]                       while (!identical(envir, .GlobalEnv) && 
[17:29:47.036]                         !identical(envir, emptyenv())) {
[17:29:47.036]                         if (exists("master", mode = "list", envir = envir, 
[17:29:47.036]                           inherits = FALSE)) {
[17:29:47.036]                           master <- get("master", mode = "list", 
[17:29:47.036]                             envir = envir, inherits = FALSE)
[17:29:47.036]                           if (inherits(master, c("SOCKnode", 
[17:29:47.036]                             "SOCK0node"))) {
[17:29:47.036]                             sendCondition <<- function(cond) {
[17:29:47.036]                               data <- list(type = "VALUE", value = cond, 
[17:29:47.036]                                 success = TRUE)
[17:29:47.036]                               parallel_sendData(master, data)
[17:29:47.036]                             }
[17:29:47.036]                             return(sendCondition)
[17:29:47.036]                           }
[17:29:47.036]                         }
[17:29:47.036]                         frame <- frame + 1L
[17:29:47.036]                         envir <- sys.frame(frame)
[17:29:47.036]                       }
[17:29:47.036]                     }
[17:29:47.036]                     sendCondition <<- function(cond) NULL
[17:29:47.036]                   }
[17:29:47.036]                 })
[17:29:47.036]                 withCallingHandlers({
[17:29:47.036]                   {
[17:29:47.036]                     sample(x, size = 1L)
[17:29:47.036]                   }
[17:29:47.036]                 }, immediateCondition = function(cond) {
[17:29:47.036]                   sendCondition <- ...future.makeSendCondition()
[17:29:47.036]                   sendCondition(cond)
[17:29:47.036]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.036]                   {
[17:29:47.036]                     inherits <- base::inherits
[17:29:47.036]                     invokeRestart <- base::invokeRestart
[17:29:47.036]                     is.null <- base::is.null
[17:29:47.036]                     muffled <- FALSE
[17:29:47.036]                     if (inherits(cond, "message")) {
[17:29:47.036]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:47.036]                       if (muffled) 
[17:29:47.036]                         invokeRestart("muffleMessage")
[17:29:47.036]                     }
[17:29:47.036]                     else if (inherits(cond, "warning")) {
[17:29:47.036]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:47.036]                       if (muffled) 
[17:29:47.036]                         invokeRestart("muffleWarning")
[17:29:47.036]                     }
[17:29:47.036]                     else if (inherits(cond, "condition")) {
[17:29:47.036]                       if (!is.null(pattern)) {
[17:29:47.036]                         computeRestarts <- base::computeRestarts
[17:29:47.036]                         grepl <- base::grepl
[17:29:47.036]                         restarts <- computeRestarts(cond)
[17:29:47.036]                         for (restart in restarts) {
[17:29:47.036]                           name <- restart$name
[17:29:47.036]                           if (is.null(name)) 
[17:29:47.036]                             next
[17:29:47.036]                           if (!grepl(pattern, name)) 
[17:29:47.036]                             next
[17:29:47.036]                           invokeRestart(restart)
[17:29:47.036]                           muffled <- TRUE
[17:29:47.036]                           break
[17:29:47.036]                         }
[17:29:47.036]                       }
[17:29:47.036]                     }
[17:29:47.036]                     invisible(muffled)
[17:29:47.036]                   }
[17:29:47.036]                   muffleCondition(cond)
[17:29:47.036]                 })
[17:29:47.036]             }))
[17:29:47.036]             future::FutureResult(value = ...future.value$value, 
[17:29:47.036]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.036]                   ...future.rng), globalenv = if (FALSE) 
[17:29:47.036]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:47.036]                     ...future.globalenv.names))
[17:29:47.036]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:47.036]         }, condition = base::local({
[17:29:47.036]             c <- base::c
[17:29:47.036]             inherits <- base::inherits
[17:29:47.036]             invokeRestart <- base::invokeRestart
[17:29:47.036]             length <- base::length
[17:29:47.036]             list <- base::list
[17:29:47.036]             seq.int <- base::seq.int
[17:29:47.036]             signalCondition <- base::signalCondition
[17:29:47.036]             sys.calls <- base::sys.calls
[17:29:47.036]             `[[` <- base::`[[`
[17:29:47.036]             `+` <- base::`+`
[17:29:47.036]             `<<-` <- base::`<<-`
[17:29:47.036]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:47.036]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:47.036]                   3L)]
[17:29:47.036]             }
[17:29:47.036]             function(cond) {
[17:29:47.036]                 is_error <- inherits(cond, "error")
[17:29:47.036]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:47.036]                   NULL)
[17:29:47.036]                 if (is_error) {
[17:29:47.036]                   sessionInformation <- function() {
[17:29:47.036]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:47.036]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:47.036]                       search = base::search(), system = base::Sys.info())
[17:29:47.036]                   }
[17:29:47.036]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.036]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:47.036]                     cond$call), session = sessionInformation(), 
[17:29:47.036]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:47.036]                   signalCondition(cond)
[17:29:47.036]                 }
[17:29:47.036]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:47.036]                 "immediateCondition"))) {
[17:29:47.036]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:47.036]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.036]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:47.036]                   if (TRUE && !signal) {
[17:29:47.036]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.036]                     {
[17:29:47.036]                       inherits <- base::inherits
[17:29:47.036]                       invokeRestart <- base::invokeRestart
[17:29:47.036]                       is.null <- base::is.null
[17:29:47.036]                       muffled <- FALSE
[17:29:47.036]                       if (inherits(cond, "message")) {
[17:29:47.036]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.036]                         if (muffled) 
[17:29:47.036]                           invokeRestart("muffleMessage")
[17:29:47.036]                       }
[17:29:47.036]                       else if (inherits(cond, "warning")) {
[17:29:47.036]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.036]                         if (muffled) 
[17:29:47.036]                           invokeRestart("muffleWarning")
[17:29:47.036]                       }
[17:29:47.036]                       else if (inherits(cond, "condition")) {
[17:29:47.036]                         if (!is.null(pattern)) {
[17:29:47.036]                           computeRestarts <- base::computeRestarts
[17:29:47.036]                           grepl <- base::grepl
[17:29:47.036]                           restarts <- computeRestarts(cond)
[17:29:47.036]                           for (restart in restarts) {
[17:29:47.036]                             name <- restart$name
[17:29:47.036]                             if (is.null(name)) 
[17:29:47.036]                               next
[17:29:47.036]                             if (!grepl(pattern, name)) 
[17:29:47.036]                               next
[17:29:47.036]                             invokeRestart(restart)
[17:29:47.036]                             muffled <- TRUE
[17:29:47.036]                             break
[17:29:47.036]                           }
[17:29:47.036]                         }
[17:29:47.036]                       }
[17:29:47.036]                       invisible(muffled)
[17:29:47.036]                     }
[17:29:47.036]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.036]                   }
[17:29:47.036]                 }
[17:29:47.036]                 else {
[17:29:47.036]                   if (TRUE) {
[17:29:47.036]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.036]                     {
[17:29:47.036]                       inherits <- base::inherits
[17:29:47.036]                       invokeRestart <- base::invokeRestart
[17:29:47.036]                       is.null <- base::is.null
[17:29:47.036]                       muffled <- FALSE
[17:29:47.036]                       if (inherits(cond, "message")) {
[17:29:47.036]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.036]                         if (muffled) 
[17:29:47.036]                           invokeRestart("muffleMessage")
[17:29:47.036]                       }
[17:29:47.036]                       else if (inherits(cond, "warning")) {
[17:29:47.036]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.036]                         if (muffled) 
[17:29:47.036]                           invokeRestart("muffleWarning")
[17:29:47.036]                       }
[17:29:47.036]                       else if (inherits(cond, "condition")) {
[17:29:47.036]                         if (!is.null(pattern)) {
[17:29:47.036]                           computeRestarts <- base::computeRestarts
[17:29:47.036]                           grepl <- base::grepl
[17:29:47.036]                           restarts <- computeRestarts(cond)
[17:29:47.036]                           for (restart in restarts) {
[17:29:47.036]                             name <- restart$name
[17:29:47.036]                             if (is.null(name)) 
[17:29:47.036]                               next
[17:29:47.036]                             if (!grepl(pattern, name)) 
[17:29:47.036]                               next
[17:29:47.036]                             invokeRestart(restart)
[17:29:47.036]                             muffled <- TRUE
[17:29:47.036]                             break
[17:29:47.036]                           }
[17:29:47.036]                         }
[17:29:47.036]                       }
[17:29:47.036]                       invisible(muffled)
[17:29:47.036]                     }
[17:29:47.036]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.036]                   }
[17:29:47.036]                 }
[17:29:47.036]             }
[17:29:47.036]         }))
[17:29:47.036]     }, error = function(ex) {
[17:29:47.036]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:47.036]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.036]                 ...future.rng), started = ...future.startTime, 
[17:29:47.036]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:47.036]             version = "1.8"), class = "FutureResult")
[17:29:47.036]     }, finally = {
[17:29:47.036]         if (!identical(...future.workdir, getwd())) 
[17:29:47.036]             setwd(...future.workdir)
[17:29:47.036]         {
[17:29:47.036]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:47.036]                 ...future.oldOptions$nwarnings <- NULL
[17:29:47.036]             }
[17:29:47.036]             base::options(...future.oldOptions)
[17:29:47.036]             if (.Platform$OS.type == "windows") {
[17:29:47.036]                 old_names <- names(...future.oldEnvVars)
[17:29:47.036]                 envs <- base::Sys.getenv()
[17:29:47.036]                 names <- names(envs)
[17:29:47.036]                 common <- intersect(names, old_names)
[17:29:47.036]                 added <- setdiff(names, old_names)
[17:29:47.036]                 removed <- setdiff(old_names, names)
[17:29:47.036]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:47.036]                   envs[common]]
[17:29:47.036]                 NAMES <- toupper(changed)
[17:29:47.036]                 args <- list()
[17:29:47.036]                 for (kk in seq_along(NAMES)) {
[17:29:47.036]                   name <- changed[[kk]]
[17:29:47.036]                   NAME <- NAMES[[kk]]
[17:29:47.036]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.036]                     next
[17:29:47.036]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.036]                 }
[17:29:47.036]                 NAMES <- toupper(added)
[17:29:47.036]                 for (kk in seq_along(NAMES)) {
[17:29:47.036]                   name <- added[[kk]]
[17:29:47.036]                   NAME <- NAMES[[kk]]
[17:29:47.036]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.036]                     next
[17:29:47.036]                   args[[name]] <- ""
[17:29:47.036]                 }
[17:29:47.036]                 NAMES <- toupper(removed)
[17:29:47.036]                 for (kk in seq_along(NAMES)) {
[17:29:47.036]                   name <- removed[[kk]]
[17:29:47.036]                   NAME <- NAMES[[kk]]
[17:29:47.036]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.036]                     next
[17:29:47.036]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.036]                 }
[17:29:47.036]                 if (length(args) > 0) 
[17:29:47.036]                   base::do.call(base::Sys.setenv, args = args)
[17:29:47.036]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:47.036]             }
[17:29:47.036]             else {
[17:29:47.036]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:47.036]             }
[17:29:47.036]             {
[17:29:47.036]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:47.036]                   0L) {
[17:29:47.036]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:47.036]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:47.036]                   base::options(opts)
[17:29:47.036]                 }
[17:29:47.036]                 {
[17:29:47.036]                   {
[17:29:47.036]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:47.036]                     NULL
[17:29:47.036]                   }
[17:29:47.036]                   options(future.plan = NULL)
[17:29:47.036]                   if (is.na(NA_character_)) 
[17:29:47.036]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.036]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:47.036]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:47.036]                     .init = FALSE)
[17:29:47.036]                 }
[17:29:47.036]             }
[17:29:47.036]         }
[17:29:47.036]     })
[17:29:47.036]     if (TRUE) {
[17:29:47.036]         base::sink(type = "output", split = FALSE)
[17:29:47.036]         if (TRUE) {
[17:29:47.036]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:47.036]         }
[17:29:47.036]         else {
[17:29:47.036]             ...future.result["stdout"] <- base::list(NULL)
[17:29:47.036]         }
[17:29:47.036]         base::close(...future.stdout)
[17:29:47.036]         ...future.stdout <- NULL
[17:29:47.036]     }
[17:29:47.036]     ...future.result$conditions <- ...future.conditions
[17:29:47.036]     ...future.result$finished <- base::Sys.time()
[17:29:47.036]     ...future.result
[17:29:47.036] }
[17:29:47.043] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:47.066] receiveMessageFromWorker() for ClusterFuture ...
[17:29:47.067] - Validating connection of MultisessionFuture
[17:29:47.067] - received message: FutureResult
[17:29:47.068] - Received FutureResult
[17:29:47.068] - Erased future from FutureRegistry
[17:29:47.069] result() for ClusterFuture ...
[17:29:47.069] - result already collected: FutureResult
[17:29:47.069] result() for ClusterFuture ... done
[17:29:47.070] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:47.070] result() for ClusterFuture ...
[17:29:47.070] - result already collected: FutureResult
[17:29:47.071] result() for ClusterFuture ... done
[17:29:47.071] result() for ClusterFuture ...
[17:29:47.071] - result already collected: FutureResult
[17:29:47.071] result() for ClusterFuture ... done
[17:29:47.073] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:47.073] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:47.074] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:47.074] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:47.076] MultisessionFuture started
[17:29:47.076] - Launch lazy future ... done
[17:29:47.076] run() for 'MultisessionFuture' ... done
[17:29:47.077] result() for ClusterFuture ...
[17:29:47.077] - result already collected: FutureResult
[17:29:47.077] result() for ClusterFuture ... done
[17:29:47.078] result() for ClusterFuture ...
[17:29:47.078] - result already collected: FutureResult
[17:29:47.078] result() for ClusterFuture ... done
[17:29:47.079] result() for ClusterFuture ...
[17:29:47.079] - result already collected: FutureResult
[17:29:47.079] result() for ClusterFuture ... done
[17:29:47.080] result() for ClusterFuture ...
[17:29:47.080] - result already collected: FutureResult
[17:29:47.080] result() for ClusterFuture ... done
[17:29:47.081] result() for ClusterFuture ...
[17:29:47.081] receiveMessageFromWorker() for ClusterFuture ...
[17:29:47.081] - Validating connection of MultisessionFuture
[17:29:47.082] - received message: FutureResult
[17:29:47.082] - Received FutureResult
[17:29:47.083] - Erased future from FutureRegistry
[17:29:47.083] result() for ClusterFuture ...
[17:29:47.083] - result already collected: FutureResult
[17:29:47.084] result() for ClusterFuture ... done
[17:29:47.084] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:47.084] result() for ClusterFuture ... done
[17:29:47.085] result() for ClusterFuture ...
[17:29:47.085] - result already collected: FutureResult
[17:29:47.085] result() for ClusterFuture ... done
[17:29:47.085] result() for ClusterFuture ...
[17:29:47.086] receiveMessageFromWorker() for ClusterFuture ...
[17:29:47.086] - Validating connection of MultisessionFuture
[17:29:47.105] - received message: FutureResult
[17:29:47.106] - Received FutureResult
[17:29:47.106] - Erased future from FutureRegistry
[17:29:47.106] result() for ClusterFuture ...
[17:29:47.107] - result already collected: FutureResult
[17:29:47.107] result() for ClusterFuture ... done
[17:29:47.107] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:47.107] result() for ClusterFuture ... done
[17:29:47.108] result() for ClusterFuture ...
[17:29:47.108] - result already collected: FutureResult
[17:29:47.108] result() for ClusterFuture ... done
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[17:29:47.109] getGlobalsAndPackages() ...
[17:29:47.109] Searching for globals...
[17:29:47.111] - globals found: [3] '{', 'sample', 'x'
[17:29:47.111] Searching for globals ... DONE
[17:29:47.111] Resolving globals: FALSE
[17:29:47.112] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:47.113] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:47.113] - globals: [1] 'x'
[17:29:47.113] 
[17:29:47.113] getGlobalsAndPackages() ... DONE
[17:29:47.114] run() for 'Future' ...
[17:29:47.114] - state: 'created'
[17:29:47.114] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:47.130] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:47.130] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:47.130]   - Field: 'node'
[17:29:47.131]   - Field: 'label'
[17:29:47.131]   - Field: 'local'
[17:29:47.131]   - Field: 'owner'
[17:29:47.131]   - Field: 'envir'
[17:29:47.132]   - Field: 'workers'
[17:29:47.132]   - Field: 'packages'
[17:29:47.132]   - Field: 'gc'
[17:29:47.132]   - Field: 'conditions'
[17:29:47.132]   - Field: 'persistent'
[17:29:47.132]   - Field: 'expr'
[17:29:47.133]   - Field: 'uuid'
[17:29:47.133]   - Field: 'seed'
[17:29:47.133]   - Field: 'version'
[17:29:47.133]   - Field: 'result'
[17:29:47.133]   - Field: 'asynchronous'
[17:29:47.133]   - Field: 'calls'
[17:29:47.134]   - Field: 'globals'
[17:29:47.134]   - Field: 'stdout'
[17:29:47.134]   - Field: 'earlySignal'
[17:29:47.134]   - Field: 'lazy'
[17:29:47.134]   - Field: 'state'
[17:29:47.134] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:47.135] - Launch lazy future ...
[17:29:47.135] Packages needed by the future expression (n = 0): <none>
[17:29:47.135] Packages needed by future strategies (n = 0): <none>
[17:29:47.136] {
[17:29:47.136]     {
[17:29:47.136]         {
[17:29:47.136]             ...future.startTime <- base::Sys.time()
[17:29:47.136]             {
[17:29:47.136]                 {
[17:29:47.136]                   {
[17:29:47.136]                     {
[17:29:47.136]                       {
[17:29:47.136]                         base::local({
[17:29:47.136]                           has_future <- base::requireNamespace("future", 
[17:29:47.136]                             quietly = TRUE)
[17:29:47.136]                           if (has_future) {
[17:29:47.136]                             ns <- base::getNamespace("future")
[17:29:47.136]                             version <- ns[[".package"]][["version"]]
[17:29:47.136]                             if (is.null(version)) 
[17:29:47.136]                               version <- utils::packageVersion("future")
[17:29:47.136]                           }
[17:29:47.136]                           else {
[17:29:47.136]                             version <- NULL
[17:29:47.136]                           }
[17:29:47.136]                           if (!has_future || version < "1.8.0") {
[17:29:47.136]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:47.136]                               "", base::R.version$version.string), 
[17:29:47.136]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:47.136]                                 base::R.version$platform, 8 * 
[17:29:47.136]                                   base::.Machine$sizeof.pointer), 
[17:29:47.136]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:47.136]                                 "release", "version")], collapse = " "), 
[17:29:47.136]                               hostname = base::Sys.info()[["nodename"]])
[17:29:47.136]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:47.136]                               info)
[17:29:47.136]                             info <- base::paste(info, collapse = "; ")
[17:29:47.136]                             if (!has_future) {
[17:29:47.136]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:47.136]                                 info)
[17:29:47.136]                             }
[17:29:47.136]                             else {
[17:29:47.136]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:47.136]                                 info, version)
[17:29:47.136]                             }
[17:29:47.136]                             base::stop(msg)
[17:29:47.136]                           }
[17:29:47.136]                         })
[17:29:47.136]                       }
[17:29:47.136]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:47.136]                       base::options(mc.cores = 1L)
[17:29:47.136]                     }
[17:29:47.136]                     ...future.strategy.old <- future::plan("list")
[17:29:47.136]                     options(future.plan = NULL)
[17:29:47.136]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.136]                     future::plan("default", .cleanup = FALSE, 
[17:29:47.136]                       .init = FALSE)
[17:29:47.136]                   }
[17:29:47.136]                   base::assign(".Random.seed", c(10407L, -94575036L, 
[17:29:47.136]                   -24861725L, 357812871L, 346211554L, -1301022835L, 
[17:29:47.136]                   440649733L), envir = base::globalenv(), inherits = FALSE)
[17:29:47.136]                 }
[17:29:47.136]                 ...future.workdir <- getwd()
[17:29:47.136]             }
[17:29:47.136]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:47.136]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:47.136]         }
[17:29:47.136]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:47.136]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:47.136]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:47.136]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:47.136]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:47.136]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:47.136]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:47.136]             base::names(...future.oldOptions))
[17:29:47.136]     }
[17:29:47.136]     if (FALSE) {
[17:29:47.136]     }
[17:29:47.136]     else {
[17:29:47.136]         if (TRUE) {
[17:29:47.136]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:47.136]                 open = "w")
[17:29:47.136]         }
[17:29:47.136]         else {
[17:29:47.136]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:47.136]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:47.136]         }
[17:29:47.136]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:47.136]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:47.136]             base::sink(type = "output", split = FALSE)
[17:29:47.136]             base::close(...future.stdout)
[17:29:47.136]         }, add = TRUE)
[17:29:47.136]     }
[17:29:47.136]     ...future.frame <- base::sys.nframe()
[17:29:47.136]     ...future.conditions <- base::list()
[17:29:47.136]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:47.136]     if (FALSE) {
[17:29:47.136]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:47.136]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:47.136]     }
[17:29:47.136]     ...future.result <- base::tryCatch({
[17:29:47.136]         base::withCallingHandlers({
[17:29:47.136]             ...future.value <- base::withVisible(base::local({
[17:29:47.136]                 ...future.makeSendCondition <- base::local({
[17:29:47.136]                   sendCondition <- NULL
[17:29:47.136]                   function(frame = 1L) {
[17:29:47.136]                     if (is.function(sendCondition)) 
[17:29:47.136]                       return(sendCondition)
[17:29:47.136]                     ns <- getNamespace("parallel")
[17:29:47.136]                     if (exists("sendData", mode = "function", 
[17:29:47.136]                       envir = ns)) {
[17:29:47.136]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:47.136]                         envir = ns)
[17:29:47.136]                       envir <- sys.frame(frame)
[17:29:47.136]                       master <- NULL
[17:29:47.136]                       while (!identical(envir, .GlobalEnv) && 
[17:29:47.136]                         !identical(envir, emptyenv())) {
[17:29:47.136]                         if (exists("master", mode = "list", envir = envir, 
[17:29:47.136]                           inherits = FALSE)) {
[17:29:47.136]                           master <- get("master", mode = "list", 
[17:29:47.136]                             envir = envir, inherits = FALSE)
[17:29:47.136]                           if (inherits(master, c("SOCKnode", 
[17:29:47.136]                             "SOCK0node"))) {
[17:29:47.136]                             sendCondition <<- function(cond) {
[17:29:47.136]                               data <- list(type = "VALUE", value = cond, 
[17:29:47.136]                                 success = TRUE)
[17:29:47.136]                               parallel_sendData(master, data)
[17:29:47.136]                             }
[17:29:47.136]                             return(sendCondition)
[17:29:47.136]                           }
[17:29:47.136]                         }
[17:29:47.136]                         frame <- frame + 1L
[17:29:47.136]                         envir <- sys.frame(frame)
[17:29:47.136]                       }
[17:29:47.136]                     }
[17:29:47.136]                     sendCondition <<- function(cond) NULL
[17:29:47.136]                   }
[17:29:47.136]                 })
[17:29:47.136]                 withCallingHandlers({
[17:29:47.136]                   {
[17:29:47.136]                     sample(x, size = 1L)
[17:29:47.136]                   }
[17:29:47.136]                 }, immediateCondition = function(cond) {
[17:29:47.136]                   sendCondition <- ...future.makeSendCondition()
[17:29:47.136]                   sendCondition(cond)
[17:29:47.136]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.136]                   {
[17:29:47.136]                     inherits <- base::inherits
[17:29:47.136]                     invokeRestart <- base::invokeRestart
[17:29:47.136]                     is.null <- base::is.null
[17:29:47.136]                     muffled <- FALSE
[17:29:47.136]                     if (inherits(cond, "message")) {
[17:29:47.136]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:47.136]                       if (muffled) 
[17:29:47.136]                         invokeRestart("muffleMessage")
[17:29:47.136]                     }
[17:29:47.136]                     else if (inherits(cond, "warning")) {
[17:29:47.136]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:47.136]                       if (muffled) 
[17:29:47.136]                         invokeRestart("muffleWarning")
[17:29:47.136]                     }
[17:29:47.136]                     else if (inherits(cond, "condition")) {
[17:29:47.136]                       if (!is.null(pattern)) {
[17:29:47.136]                         computeRestarts <- base::computeRestarts
[17:29:47.136]                         grepl <- base::grepl
[17:29:47.136]                         restarts <- computeRestarts(cond)
[17:29:47.136]                         for (restart in restarts) {
[17:29:47.136]                           name <- restart$name
[17:29:47.136]                           if (is.null(name)) 
[17:29:47.136]                             next
[17:29:47.136]                           if (!grepl(pattern, name)) 
[17:29:47.136]                             next
[17:29:47.136]                           invokeRestart(restart)
[17:29:47.136]                           muffled <- TRUE
[17:29:47.136]                           break
[17:29:47.136]                         }
[17:29:47.136]                       }
[17:29:47.136]                     }
[17:29:47.136]                     invisible(muffled)
[17:29:47.136]                   }
[17:29:47.136]                   muffleCondition(cond)
[17:29:47.136]                 })
[17:29:47.136]             }))
[17:29:47.136]             future::FutureResult(value = ...future.value$value, 
[17:29:47.136]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.136]                   ...future.rng), globalenv = if (FALSE) 
[17:29:47.136]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:47.136]                     ...future.globalenv.names))
[17:29:47.136]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:47.136]         }, condition = base::local({
[17:29:47.136]             c <- base::c
[17:29:47.136]             inherits <- base::inherits
[17:29:47.136]             invokeRestart <- base::invokeRestart
[17:29:47.136]             length <- base::length
[17:29:47.136]             list <- base::list
[17:29:47.136]             seq.int <- base::seq.int
[17:29:47.136]             signalCondition <- base::signalCondition
[17:29:47.136]             sys.calls <- base::sys.calls
[17:29:47.136]             `[[` <- base::`[[`
[17:29:47.136]             `+` <- base::`+`
[17:29:47.136]             `<<-` <- base::`<<-`
[17:29:47.136]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:47.136]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:47.136]                   3L)]
[17:29:47.136]             }
[17:29:47.136]             function(cond) {
[17:29:47.136]                 is_error <- inherits(cond, "error")
[17:29:47.136]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:47.136]                   NULL)
[17:29:47.136]                 if (is_error) {
[17:29:47.136]                   sessionInformation <- function() {
[17:29:47.136]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:47.136]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:47.136]                       search = base::search(), system = base::Sys.info())
[17:29:47.136]                   }
[17:29:47.136]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.136]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:47.136]                     cond$call), session = sessionInformation(), 
[17:29:47.136]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:47.136]                   signalCondition(cond)
[17:29:47.136]                 }
[17:29:47.136]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:47.136]                 "immediateCondition"))) {
[17:29:47.136]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:47.136]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.136]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:47.136]                   if (TRUE && !signal) {
[17:29:47.136]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.136]                     {
[17:29:47.136]                       inherits <- base::inherits
[17:29:47.136]                       invokeRestart <- base::invokeRestart
[17:29:47.136]                       is.null <- base::is.null
[17:29:47.136]                       muffled <- FALSE
[17:29:47.136]                       if (inherits(cond, "message")) {
[17:29:47.136]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.136]                         if (muffled) 
[17:29:47.136]                           invokeRestart("muffleMessage")
[17:29:47.136]                       }
[17:29:47.136]                       else if (inherits(cond, "warning")) {
[17:29:47.136]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.136]                         if (muffled) 
[17:29:47.136]                           invokeRestart("muffleWarning")
[17:29:47.136]                       }
[17:29:47.136]                       else if (inherits(cond, "condition")) {
[17:29:47.136]                         if (!is.null(pattern)) {
[17:29:47.136]                           computeRestarts <- base::computeRestarts
[17:29:47.136]                           grepl <- base::grepl
[17:29:47.136]                           restarts <- computeRestarts(cond)
[17:29:47.136]                           for (restart in restarts) {
[17:29:47.136]                             name <- restart$name
[17:29:47.136]                             if (is.null(name)) 
[17:29:47.136]                               next
[17:29:47.136]                             if (!grepl(pattern, name)) 
[17:29:47.136]                               next
[17:29:47.136]                             invokeRestart(restart)
[17:29:47.136]                             muffled <- TRUE
[17:29:47.136]                             break
[17:29:47.136]                           }
[17:29:47.136]                         }
[17:29:47.136]                       }
[17:29:47.136]                       invisible(muffled)
[17:29:47.136]                     }
[17:29:47.136]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.136]                   }
[17:29:47.136]                 }
[17:29:47.136]                 else {
[17:29:47.136]                   if (TRUE) {
[17:29:47.136]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.136]                     {
[17:29:47.136]                       inherits <- base::inherits
[17:29:47.136]                       invokeRestart <- base::invokeRestart
[17:29:47.136]                       is.null <- base::is.null
[17:29:47.136]                       muffled <- FALSE
[17:29:47.136]                       if (inherits(cond, "message")) {
[17:29:47.136]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.136]                         if (muffled) 
[17:29:47.136]                           invokeRestart("muffleMessage")
[17:29:47.136]                       }
[17:29:47.136]                       else if (inherits(cond, "warning")) {
[17:29:47.136]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.136]                         if (muffled) 
[17:29:47.136]                           invokeRestart("muffleWarning")
[17:29:47.136]                       }
[17:29:47.136]                       else if (inherits(cond, "condition")) {
[17:29:47.136]                         if (!is.null(pattern)) {
[17:29:47.136]                           computeRestarts <- base::computeRestarts
[17:29:47.136]                           grepl <- base::grepl
[17:29:47.136]                           restarts <- computeRestarts(cond)
[17:29:47.136]                           for (restart in restarts) {
[17:29:47.136]                             name <- restart$name
[17:29:47.136]                             if (is.null(name)) 
[17:29:47.136]                               next
[17:29:47.136]                             if (!grepl(pattern, name)) 
[17:29:47.136]                               next
[17:29:47.136]                             invokeRestart(restart)
[17:29:47.136]                             muffled <- TRUE
[17:29:47.136]                             break
[17:29:47.136]                           }
[17:29:47.136]                         }
[17:29:47.136]                       }
[17:29:47.136]                       invisible(muffled)
[17:29:47.136]                     }
[17:29:47.136]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.136]                   }
[17:29:47.136]                 }
[17:29:47.136]             }
[17:29:47.136]         }))
[17:29:47.136]     }, error = function(ex) {
[17:29:47.136]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:47.136]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.136]                 ...future.rng), started = ...future.startTime, 
[17:29:47.136]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:47.136]             version = "1.8"), class = "FutureResult")
[17:29:47.136]     }, finally = {
[17:29:47.136]         if (!identical(...future.workdir, getwd())) 
[17:29:47.136]             setwd(...future.workdir)
[17:29:47.136]         {
[17:29:47.136]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:47.136]                 ...future.oldOptions$nwarnings <- NULL
[17:29:47.136]             }
[17:29:47.136]             base::options(...future.oldOptions)
[17:29:47.136]             if (.Platform$OS.type == "windows") {
[17:29:47.136]                 old_names <- names(...future.oldEnvVars)
[17:29:47.136]                 envs <- base::Sys.getenv()
[17:29:47.136]                 names <- names(envs)
[17:29:47.136]                 common <- intersect(names, old_names)
[17:29:47.136]                 added <- setdiff(names, old_names)
[17:29:47.136]                 removed <- setdiff(old_names, names)
[17:29:47.136]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:47.136]                   envs[common]]
[17:29:47.136]                 NAMES <- toupper(changed)
[17:29:47.136]                 args <- list()
[17:29:47.136]                 for (kk in seq_along(NAMES)) {
[17:29:47.136]                   name <- changed[[kk]]
[17:29:47.136]                   NAME <- NAMES[[kk]]
[17:29:47.136]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.136]                     next
[17:29:47.136]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.136]                 }
[17:29:47.136]                 NAMES <- toupper(added)
[17:29:47.136]                 for (kk in seq_along(NAMES)) {
[17:29:47.136]                   name <- added[[kk]]
[17:29:47.136]                   NAME <- NAMES[[kk]]
[17:29:47.136]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.136]                     next
[17:29:47.136]                   args[[name]] <- ""
[17:29:47.136]                 }
[17:29:47.136]                 NAMES <- toupper(removed)
[17:29:47.136]                 for (kk in seq_along(NAMES)) {
[17:29:47.136]                   name <- removed[[kk]]
[17:29:47.136]                   NAME <- NAMES[[kk]]
[17:29:47.136]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.136]                     next
[17:29:47.136]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.136]                 }
[17:29:47.136]                 if (length(args) > 0) 
[17:29:47.136]                   base::do.call(base::Sys.setenv, args = args)
[17:29:47.136]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:47.136]             }
[17:29:47.136]             else {
[17:29:47.136]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:47.136]             }
[17:29:47.136]             {
[17:29:47.136]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:47.136]                   0L) {
[17:29:47.136]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:47.136]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:47.136]                   base::options(opts)
[17:29:47.136]                 }
[17:29:47.136]                 {
[17:29:47.136]                   {
[17:29:47.136]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:47.136]                     NULL
[17:29:47.136]                   }
[17:29:47.136]                   options(future.plan = NULL)
[17:29:47.136]                   if (is.na(NA_character_)) 
[17:29:47.136]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.136]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:47.136]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:47.136]                     .init = FALSE)
[17:29:47.136]                 }
[17:29:47.136]             }
[17:29:47.136]         }
[17:29:47.136]     })
[17:29:47.136]     if (TRUE) {
[17:29:47.136]         base::sink(type = "output", split = FALSE)
[17:29:47.136]         if (TRUE) {
[17:29:47.136]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:47.136]         }
[17:29:47.136]         else {
[17:29:47.136]             ...future.result["stdout"] <- base::list(NULL)
[17:29:47.136]         }
[17:29:47.136]         base::close(...future.stdout)
[17:29:47.136]         ...future.stdout <- NULL
[17:29:47.136]     }
[17:29:47.136]     ...future.result$conditions <- ...future.conditions
[17:29:47.136]     ...future.result$finished <- base::Sys.time()
[17:29:47.136]     ...future.result
[17:29:47.136] }
[17:29:47.141] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:47.142] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:47.142] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:47.142] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:47.143] MultisessionFuture started
[17:29:47.143] - Launch lazy future ... done
[17:29:47.143] run() for 'MultisessionFuture' ... done
[17:29:47.144] getGlobalsAndPackages() ...
[17:29:47.144] Searching for globals...
[17:29:47.146] - globals found: [3] '{', 'sample', 'x'
[17:29:47.146] Searching for globals ... DONE
[17:29:47.147] Resolving globals: FALSE
[17:29:47.147] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:47.148] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:47.148] - globals: [1] 'x'
[17:29:47.148] 
[17:29:47.149] getGlobalsAndPackages() ... DONE
[17:29:47.149] run() for 'Future' ...
[17:29:47.149] - state: 'created'
[17:29:47.150] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:47.166] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:47.166] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:47.167]   - Field: 'node'
[17:29:47.167]   - Field: 'label'
[17:29:47.167]   - Field: 'local'
[17:29:47.168]   - Field: 'owner'
[17:29:47.168]   - Field: 'envir'
[17:29:47.168]   - Field: 'workers'
[17:29:47.168]   - Field: 'packages'
[17:29:47.169]   - Field: 'gc'
[17:29:47.169]   - Field: 'conditions'
[17:29:47.169]   - Field: 'persistent'
[17:29:47.169]   - Field: 'expr'
[17:29:47.169]   - Field: 'uuid'
[17:29:47.169]   - Field: 'seed'
[17:29:47.169]   - Field: 'version'
[17:29:47.170]   - Field: 'result'
[17:29:47.170]   - Field: 'asynchronous'
[17:29:47.170]   - Field: 'calls'
[17:29:47.170]   - Field: 'globals'
[17:29:47.170]   - Field: 'stdout'
[17:29:47.171]   - Field: 'earlySignal'
[17:29:47.171]   - Field: 'lazy'
[17:29:47.171]   - Field: 'state'
[17:29:47.171] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:47.171] - Launch lazy future ...
[17:29:47.172] Packages needed by the future expression (n = 0): <none>
[17:29:47.172] Packages needed by future strategies (n = 0): <none>
[17:29:47.172] {
[17:29:47.172]     {
[17:29:47.172]         {
[17:29:47.172]             ...future.startTime <- base::Sys.time()
[17:29:47.172]             {
[17:29:47.172]                 {
[17:29:47.172]                   {
[17:29:47.172]                     {
[17:29:47.172]                       {
[17:29:47.172]                         base::local({
[17:29:47.172]                           has_future <- base::requireNamespace("future", 
[17:29:47.172]                             quietly = TRUE)
[17:29:47.172]                           if (has_future) {
[17:29:47.172]                             ns <- base::getNamespace("future")
[17:29:47.172]                             version <- ns[[".package"]][["version"]]
[17:29:47.172]                             if (is.null(version)) 
[17:29:47.172]                               version <- utils::packageVersion("future")
[17:29:47.172]                           }
[17:29:47.172]                           else {
[17:29:47.172]                             version <- NULL
[17:29:47.172]                           }
[17:29:47.172]                           if (!has_future || version < "1.8.0") {
[17:29:47.172]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:47.172]                               "", base::R.version$version.string), 
[17:29:47.172]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:47.172]                                 base::R.version$platform, 8 * 
[17:29:47.172]                                   base::.Machine$sizeof.pointer), 
[17:29:47.172]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:47.172]                                 "release", "version")], collapse = " "), 
[17:29:47.172]                               hostname = base::Sys.info()[["nodename"]])
[17:29:47.172]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:47.172]                               info)
[17:29:47.172]                             info <- base::paste(info, collapse = "; ")
[17:29:47.172]                             if (!has_future) {
[17:29:47.172]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:47.172]                                 info)
[17:29:47.172]                             }
[17:29:47.172]                             else {
[17:29:47.172]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:47.172]                                 info, version)
[17:29:47.172]                             }
[17:29:47.172]                             base::stop(msg)
[17:29:47.172]                           }
[17:29:47.172]                         })
[17:29:47.172]                       }
[17:29:47.172]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:47.172]                       base::options(mc.cores = 1L)
[17:29:47.172]                     }
[17:29:47.172]                     ...future.strategy.old <- future::plan("list")
[17:29:47.172]                     options(future.plan = NULL)
[17:29:47.172]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.172]                     future::plan("default", .cleanup = FALSE, 
[17:29:47.172]                       .init = FALSE)
[17:29:47.172]                   }
[17:29:47.172]                   base::assign(".Random.seed", c(10407L, -358246211L, 
[17:29:47.172]                   -1411857254L, -488221791L, 1069515918L, -1720689715L, 
[17:29:47.172]                   1070199760L), envir = base::globalenv(), inherits = FALSE)
[17:29:47.172]                 }
[17:29:47.172]                 ...future.workdir <- getwd()
[17:29:47.172]             }
[17:29:47.172]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:47.172]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:47.172]         }
[17:29:47.172]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:47.172]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:47.172]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:47.172]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:47.172]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:47.172]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:47.172]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:47.172]             base::names(...future.oldOptions))
[17:29:47.172]     }
[17:29:47.172]     if (FALSE) {
[17:29:47.172]     }
[17:29:47.172]     else {
[17:29:47.172]         if (TRUE) {
[17:29:47.172]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:47.172]                 open = "w")
[17:29:47.172]         }
[17:29:47.172]         else {
[17:29:47.172]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:47.172]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:47.172]         }
[17:29:47.172]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:47.172]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:47.172]             base::sink(type = "output", split = FALSE)
[17:29:47.172]             base::close(...future.stdout)
[17:29:47.172]         }, add = TRUE)
[17:29:47.172]     }
[17:29:47.172]     ...future.frame <- base::sys.nframe()
[17:29:47.172]     ...future.conditions <- base::list()
[17:29:47.172]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:47.172]     if (FALSE) {
[17:29:47.172]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:47.172]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:47.172]     }
[17:29:47.172]     ...future.result <- base::tryCatch({
[17:29:47.172]         base::withCallingHandlers({
[17:29:47.172]             ...future.value <- base::withVisible(base::local({
[17:29:47.172]                 ...future.makeSendCondition <- base::local({
[17:29:47.172]                   sendCondition <- NULL
[17:29:47.172]                   function(frame = 1L) {
[17:29:47.172]                     if (is.function(sendCondition)) 
[17:29:47.172]                       return(sendCondition)
[17:29:47.172]                     ns <- getNamespace("parallel")
[17:29:47.172]                     if (exists("sendData", mode = "function", 
[17:29:47.172]                       envir = ns)) {
[17:29:47.172]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:47.172]                         envir = ns)
[17:29:47.172]                       envir <- sys.frame(frame)
[17:29:47.172]                       master <- NULL
[17:29:47.172]                       while (!identical(envir, .GlobalEnv) && 
[17:29:47.172]                         !identical(envir, emptyenv())) {
[17:29:47.172]                         if (exists("master", mode = "list", envir = envir, 
[17:29:47.172]                           inherits = FALSE)) {
[17:29:47.172]                           master <- get("master", mode = "list", 
[17:29:47.172]                             envir = envir, inherits = FALSE)
[17:29:47.172]                           if (inherits(master, c("SOCKnode", 
[17:29:47.172]                             "SOCK0node"))) {
[17:29:47.172]                             sendCondition <<- function(cond) {
[17:29:47.172]                               data <- list(type = "VALUE", value = cond, 
[17:29:47.172]                                 success = TRUE)
[17:29:47.172]                               parallel_sendData(master, data)
[17:29:47.172]                             }
[17:29:47.172]                             return(sendCondition)
[17:29:47.172]                           }
[17:29:47.172]                         }
[17:29:47.172]                         frame <- frame + 1L
[17:29:47.172]                         envir <- sys.frame(frame)
[17:29:47.172]                       }
[17:29:47.172]                     }
[17:29:47.172]                     sendCondition <<- function(cond) NULL
[17:29:47.172]                   }
[17:29:47.172]                 })
[17:29:47.172]                 withCallingHandlers({
[17:29:47.172]                   {
[17:29:47.172]                     sample(x, size = 1L)
[17:29:47.172]                   }
[17:29:47.172]                 }, immediateCondition = function(cond) {
[17:29:47.172]                   sendCondition <- ...future.makeSendCondition()
[17:29:47.172]                   sendCondition(cond)
[17:29:47.172]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.172]                   {
[17:29:47.172]                     inherits <- base::inherits
[17:29:47.172]                     invokeRestart <- base::invokeRestart
[17:29:47.172]                     is.null <- base::is.null
[17:29:47.172]                     muffled <- FALSE
[17:29:47.172]                     if (inherits(cond, "message")) {
[17:29:47.172]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:47.172]                       if (muffled) 
[17:29:47.172]                         invokeRestart("muffleMessage")
[17:29:47.172]                     }
[17:29:47.172]                     else if (inherits(cond, "warning")) {
[17:29:47.172]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:47.172]                       if (muffled) 
[17:29:47.172]                         invokeRestart("muffleWarning")
[17:29:47.172]                     }
[17:29:47.172]                     else if (inherits(cond, "condition")) {
[17:29:47.172]                       if (!is.null(pattern)) {
[17:29:47.172]                         computeRestarts <- base::computeRestarts
[17:29:47.172]                         grepl <- base::grepl
[17:29:47.172]                         restarts <- computeRestarts(cond)
[17:29:47.172]                         for (restart in restarts) {
[17:29:47.172]                           name <- restart$name
[17:29:47.172]                           if (is.null(name)) 
[17:29:47.172]                             next
[17:29:47.172]                           if (!grepl(pattern, name)) 
[17:29:47.172]                             next
[17:29:47.172]                           invokeRestart(restart)
[17:29:47.172]                           muffled <- TRUE
[17:29:47.172]                           break
[17:29:47.172]                         }
[17:29:47.172]                       }
[17:29:47.172]                     }
[17:29:47.172]                     invisible(muffled)
[17:29:47.172]                   }
[17:29:47.172]                   muffleCondition(cond)
[17:29:47.172]                 })
[17:29:47.172]             }))
[17:29:47.172]             future::FutureResult(value = ...future.value$value, 
[17:29:47.172]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.172]                   ...future.rng), globalenv = if (FALSE) 
[17:29:47.172]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:47.172]                     ...future.globalenv.names))
[17:29:47.172]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:47.172]         }, condition = base::local({
[17:29:47.172]             c <- base::c
[17:29:47.172]             inherits <- base::inherits
[17:29:47.172]             invokeRestart <- base::invokeRestart
[17:29:47.172]             length <- base::length
[17:29:47.172]             list <- base::list
[17:29:47.172]             seq.int <- base::seq.int
[17:29:47.172]             signalCondition <- base::signalCondition
[17:29:47.172]             sys.calls <- base::sys.calls
[17:29:47.172]             `[[` <- base::`[[`
[17:29:47.172]             `+` <- base::`+`
[17:29:47.172]             `<<-` <- base::`<<-`
[17:29:47.172]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:47.172]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:47.172]                   3L)]
[17:29:47.172]             }
[17:29:47.172]             function(cond) {
[17:29:47.172]                 is_error <- inherits(cond, "error")
[17:29:47.172]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:47.172]                   NULL)
[17:29:47.172]                 if (is_error) {
[17:29:47.172]                   sessionInformation <- function() {
[17:29:47.172]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:47.172]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:47.172]                       search = base::search(), system = base::Sys.info())
[17:29:47.172]                   }
[17:29:47.172]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.172]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:47.172]                     cond$call), session = sessionInformation(), 
[17:29:47.172]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:47.172]                   signalCondition(cond)
[17:29:47.172]                 }
[17:29:47.172]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:47.172]                 "immediateCondition"))) {
[17:29:47.172]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:47.172]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.172]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:47.172]                   if (TRUE && !signal) {
[17:29:47.172]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.172]                     {
[17:29:47.172]                       inherits <- base::inherits
[17:29:47.172]                       invokeRestart <- base::invokeRestart
[17:29:47.172]                       is.null <- base::is.null
[17:29:47.172]                       muffled <- FALSE
[17:29:47.172]                       if (inherits(cond, "message")) {
[17:29:47.172]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.172]                         if (muffled) 
[17:29:47.172]                           invokeRestart("muffleMessage")
[17:29:47.172]                       }
[17:29:47.172]                       else if (inherits(cond, "warning")) {
[17:29:47.172]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.172]                         if (muffled) 
[17:29:47.172]                           invokeRestart("muffleWarning")
[17:29:47.172]                       }
[17:29:47.172]                       else if (inherits(cond, "condition")) {
[17:29:47.172]                         if (!is.null(pattern)) {
[17:29:47.172]                           computeRestarts <- base::computeRestarts
[17:29:47.172]                           grepl <- base::grepl
[17:29:47.172]                           restarts <- computeRestarts(cond)
[17:29:47.172]                           for (restart in restarts) {
[17:29:47.172]                             name <- restart$name
[17:29:47.172]                             if (is.null(name)) 
[17:29:47.172]                               next
[17:29:47.172]                             if (!grepl(pattern, name)) 
[17:29:47.172]                               next
[17:29:47.172]                             invokeRestart(restart)
[17:29:47.172]                             muffled <- TRUE
[17:29:47.172]                             break
[17:29:47.172]                           }
[17:29:47.172]                         }
[17:29:47.172]                       }
[17:29:47.172]                       invisible(muffled)
[17:29:47.172]                     }
[17:29:47.172]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.172]                   }
[17:29:47.172]                 }
[17:29:47.172]                 else {
[17:29:47.172]                   if (TRUE) {
[17:29:47.172]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.172]                     {
[17:29:47.172]                       inherits <- base::inherits
[17:29:47.172]                       invokeRestart <- base::invokeRestart
[17:29:47.172]                       is.null <- base::is.null
[17:29:47.172]                       muffled <- FALSE
[17:29:47.172]                       if (inherits(cond, "message")) {
[17:29:47.172]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.172]                         if (muffled) 
[17:29:47.172]                           invokeRestart("muffleMessage")
[17:29:47.172]                       }
[17:29:47.172]                       else if (inherits(cond, "warning")) {
[17:29:47.172]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.172]                         if (muffled) 
[17:29:47.172]                           invokeRestart("muffleWarning")
[17:29:47.172]                       }
[17:29:47.172]                       else if (inherits(cond, "condition")) {
[17:29:47.172]                         if (!is.null(pattern)) {
[17:29:47.172]                           computeRestarts <- base::computeRestarts
[17:29:47.172]                           grepl <- base::grepl
[17:29:47.172]                           restarts <- computeRestarts(cond)
[17:29:47.172]                           for (restart in restarts) {
[17:29:47.172]                             name <- restart$name
[17:29:47.172]                             if (is.null(name)) 
[17:29:47.172]                               next
[17:29:47.172]                             if (!grepl(pattern, name)) 
[17:29:47.172]                               next
[17:29:47.172]                             invokeRestart(restart)
[17:29:47.172]                             muffled <- TRUE
[17:29:47.172]                             break
[17:29:47.172]                           }
[17:29:47.172]                         }
[17:29:47.172]                       }
[17:29:47.172]                       invisible(muffled)
[17:29:47.172]                     }
[17:29:47.172]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.172]                   }
[17:29:47.172]                 }
[17:29:47.172]             }
[17:29:47.172]         }))
[17:29:47.172]     }, error = function(ex) {
[17:29:47.172]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:47.172]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.172]                 ...future.rng), started = ...future.startTime, 
[17:29:47.172]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:47.172]             version = "1.8"), class = "FutureResult")
[17:29:47.172]     }, finally = {
[17:29:47.172]         if (!identical(...future.workdir, getwd())) 
[17:29:47.172]             setwd(...future.workdir)
[17:29:47.172]         {
[17:29:47.172]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:47.172]                 ...future.oldOptions$nwarnings <- NULL
[17:29:47.172]             }
[17:29:47.172]             base::options(...future.oldOptions)
[17:29:47.172]             if (.Platform$OS.type == "windows") {
[17:29:47.172]                 old_names <- names(...future.oldEnvVars)
[17:29:47.172]                 envs <- base::Sys.getenv()
[17:29:47.172]                 names <- names(envs)
[17:29:47.172]                 common <- intersect(names, old_names)
[17:29:47.172]                 added <- setdiff(names, old_names)
[17:29:47.172]                 removed <- setdiff(old_names, names)
[17:29:47.172]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:47.172]                   envs[common]]
[17:29:47.172]                 NAMES <- toupper(changed)
[17:29:47.172]                 args <- list()
[17:29:47.172]                 for (kk in seq_along(NAMES)) {
[17:29:47.172]                   name <- changed[[kk]]
[17:29:47.172]                   NAME <- NAMES[[kk]]
[17:29:47.172]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.172]                     next
[17:29:47.172]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.172]                 }
[17:29:47.172]                 NAMES <- toupper(added)
[17:29:47.172]                 for (kk in seq_along(NAMES)) {
[17:29:47.172]                   name <- added[[kk]]
[17:29:47.172]                   NAME <- NAMES[[kk]]
[17:29:47.172]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.172]                     next
[17:29:47.172]                   args[[name]] <- ""
[17:29:47.172]                 }
[17:29:47.172]                 NAMES <- toupper(removed)
[17:29:47.172]                 for (kk in seq_along(NAMES)) {
[17:29:47.172]                   name <- removed[[kk]]
[17:29:47.172]                   NAME <- NAMES[[kk]]
[17:29:47.172]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.172]                     next
[17:29:47.172]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.172]                 }
[17:29:47.172]                 if (length(args) > 0) 
[17:29:47.172]                   base::do.call(base::Sys.setenv, args = args)
[17:29:47.172]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:47.172]             }
[17:29:47.172]             else {
[17:29:47.172]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:47.172]             }
[17:29:47.172]             {
[17:29:47.172]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:47.172]                   0L) {
[17:29:47.172]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:47.172]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:47.172]                   base::options(opts)
[17:29:47.172]                 }
[17:29:47.172]                 {
[17:29:47.172]                   {
[17:29:47.172]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:47.172]                     NULL
[17:29:47.172]                   }
[17:29:47.172]                   options(future.plan = NULL)
[17:29:47.172]                   if (is.na(NA_character_)) 
[17:29:47.172]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.172]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:47.172]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:47.172]                     .init = FALSE)
[17:29:47.172]                 }
[17:29:47.172]             }
[17:29:47.172]         }
[17:29:47.172]     })
[17:29:47.172]     if (TRUE) {
[17:29:47.172]         base::sink(type = "output", split = FALSE)
[17:29:47.172]         if (TRUE) {
[17:29:47.172]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:47.172]         }
[17:29:47.172]         else {
[17:29:47.172]             ...future.result["stdout"] <- base::list(NULL)
[17:29:47.172]         }
[17:29:47.172]         base::close(...future.stdout)
[17:29:47.172]         ...future.stdout <- NULL
[17:29:47.172]     }
[17:29:47.172]     ...future.result$conditions <- ...future.conditions
[17:29:47.172]     ...future.result$finished <- base::Sys.time()
[17:29:47.172]     ...future.result
[17:29:47.172] }
[17:29:47.178] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:47.178] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:47.179] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:47.179] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:47.180] MultisessionFuture started
[17:29:47.180] - Launch lazy future ... done
[17:29:47.180] run() for 'MultisessionFuture' ... done
[17:29:47.181] getGlobalsAndPackages() ...
[17:29:47.181] Searching for globals...
[17:29:47.183] - globals found: [3] '{', 'sample', 'x'
[17:29:47.183] Searching for globals ... DONE
[17:29:47.184] Resolving globals: FALSE
[17:29:47.184] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:47.185] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:47.185] - globals: [1] 'x'
[17:29:47.185] 
[17:29:47.186] getGlobalsAndPackages() ... DONE
[17:29:47.186] run() for 'Future' ...
[17:29:47.187] - state: 'created'
[17:29:47.187] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:47.206] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:47.206] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:47.206]   - Field: 'node'
[17:29:47.207]   - Field: 'label'
[17:29:47.207]   - Field: 'local'
[17:29:47.207]   - Field: 'owner'
[17:29:47.208]   - Field: 'envir'
[17:29:47.208]   - Field: 'workers'
[17:29:47.208]   - Field: 'packages'
[17:29:47.208]   - Field: 'gc'
[17:29:47.209]   - Field: 'conditions'
[17:29:47.209]   - Field: 'persistent'
[17:29:47.209]   - Field: 'expr'
[17:29:47.209]   - Field: 'uuid'
[17:29:47.209]   - Field: 'seed'
[17:29:47.210]   - Field: 'version'
[17:29:47.210]   - Field: 'result'
[17:29:47.210]   - Field: 'asynchronous'
[17:29:47.210]   - Field: 'calls'
[17:29:47.211]   - Field: 'globals'
[17:29:47.211]   - Field: 'stdout'
[17:29:47.211]   - Field: 'earlySignal'
[17:29:47.211]   - Field: 'lazy'
[17:29:47.212]   - Field: 'state'
[17:29:47.212] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:47.212] - Launch lazy future ...
[17:29:47.213] Packages needed by the future expression (n = 0): <none>
[17:29:47.213] Packages needed by future strategies (n = 0): <none>
[17:29:47.214] {
[17:29:47.214]     {
[17:29:47.214]         {
[17:29:47.214]             ...future.startTime <- base::Sys.time()
[17:29:47.214]             {
[17:29:47.214]                 {
[17:29:47.214]                   {
[17:29:47.214]                     {
[17:29:47.214]                       {
[17:29:47.214]                         base::local({
[17:29:47.214]                           has_future <- base::requireNamespace("future", 
[17:29:47.214]                             quietly = TRUE)
[17:29:47.214]                           if (has_future) {
[17:29:47.214]                             ns <- base::getNamespace("future")
[17:29:47.214]                             version <- ns[[".package"]][["version"]]
[17:29:47.214]                             if (is.null(version)) 
[17:29:47.214]                               version <- utils::packageVersion("future")
[17:29:47.214]                           }
[17:29:47.214]                           else {
[17:29:47.214]                             version <- NULL
[17:29:47.214]                           }
[17:29:47.214]                           if (!has_future || version < "1.8.0") {
[17:29:47.214]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:47.214]                               "", base::R.version$version.string), 
[17:29:47.214]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:47.214]                                 base::R.version$platform, 8 * 
[17:29:47.214]                                   base::.Machine$sizeof.pointer), 
[17:29:47.214]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:47.214]                                 "release", "version")], collapse = " "), 
[17:29:47.214]                               hostname = base::Sys.info()[["nodename"]])
[17:29:47.214]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:47.214]                               info)
[17:29:47.214]                             info <- base::paste(info, collapse = "; ")
[17:29:47.214]                             if (!has_future) {
[17:29:47.214]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:47.214]                                 info)
[17:29:47.214]                             }
[17:29:47.214]                             else {
[17:29:47.214]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:47.214]                                 info, version)
[17:29:47.214]                             }
[17:29:47.214]                             base::stop(msg)
[17:29:47.214]                           }
[17:29:47.214]                         })
[17:29:47.214]                       }
[17:29:47.214]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:47.214]                       base::options(mc.cores = 1L)
[17:29:47.214]                     }
[17:29:47.214]                     ...future.strategy.old <- future::plan("list")
[17:29:47.214]                     options(future.plan = NULL)
[17:29:47.214]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.214]                     future::plan("default", .cleanup = FALSE, 
[17:29:47.214]                       .init = FALSE)
[17:29:47.214]                   }
[17:29:47.214]                   base::assign(".Random.seed", c(10407L, 1805183335L, 
[17:29:47.214]                   -1982978684L, 1500882842L, -1897959390L, -204266259L, 
[17:29:47.214]                   -2006625641L), envir = base::globalenv(), inherits = FALSE)
[17:29:47.214]                 }
[17:29:47.214]                 ...future.workdir <- getwd()
[17:29:47.214]             }
[17:29:47.214]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:47.214]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:47.214]         }
[17:29:47.214]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:47.214]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:47.214]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:47.214]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:47.214]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:47.214]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:47.214]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:47.214]             base::names(...future.oldOptions))
[17:29:47.214]     }
[17:29:47.214]     if (FALSE) {
[17:29:47.214]     }
[17:29:47.214]     else {
[17:29:47.214]         if (TRUE) {
[17:29:47.214]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:47.214]                 open = "w")
[17:29:47.214]         }
[17:29:47.214]         else {
[17:29:47.214]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:47.214]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:47.214]         }
[17:29:47.214]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:47.214]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:47.214]             base::sink(type = "output", split = FALSE)
[17:29:47.214]             base::close(...future.stdout)
[17:29:47.214]         }, add = TRUE)
[17:29:47.214]     }
[17:29:47.214]     ...future.frame <- base::sys.nframe()
[17:29:47.214]     ...future.conditions <- base::list()
[17:29:47.214]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:47.214]     if (FALSE) {
[17:29:47.214]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:47.214]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:47.214]     }
[17:29:47.214]     ...future.result <- base::tryCatch({
[17:29:47.214]         base::withCallingHandlers({
[17:29:47.214]             ...future.value <- base::withVisible(base::local({
[17:29:47.214]                 ...future.makeSendCondition <- base::local({
[17:29:47.214]                   sendCondition <- NULL
[17:29:47.214]                   function(frame = 1L) {
[17:29:47.214]                     if (is.function(sendCondition)) 
[17:29:47.214]                       return(sendCondition)
[17:29:47.214]                     ns <- getNamespace("parallel")
[17:29:47.214]                     if (exists("sendData", mode = "function", 
[17:29:47.214]                       envir = ns)) {
[17:29:47.214]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:47.214]                         envir = ns)
[17:29:47.214]                       envir <- sys.frame(frame)
[17:29:47.214]                       master <- NULL
[17:29:47.214]                       while (!identical(envir, .GlobalEnv) && 
[17:29:47.214]                         !identical(envir, emptyenv())) {
[17:29:47.214]                         if (exists("master", mode = "list", envir = envir, 
[17:29:47.214]                           inherits = FALSE)) {
[17:29:47.214]                           master <- get("master", mode = "list", 
[17:29:47.214]                             envir = envir, inherits = FALSE)
[17:29:47.214]                           if (inherits(master, c("SOCKnode", 
[17:29:47.214]                             "SOCK0node"))) {
[17:29:47.214]                             sendCondition <<- function(cond) {
[17:29:47.214]                               data <- list(type = "VALUE", value = cond, 
[17:29:47.214]                                 success = TRUE)
[17:29:47.214]                               parallel_sendData(master, data)
[17:29:47.214]                             }
[17:29:47.214]                             return(sendCondition)
[17:29:47.214]                           }
[17:29:47.214]                         }
[17:29:47.214]                         frame <- frame + 1L
[17:29:47.214]                         envir <- sys.frame(frame)
[17:29:47.214]                       }
[17:29:47.214]                     }
[17:29:47.214]                     sendCondition <<- function(cond) NULL
[17:29:47.214]                   }
[17:29:47.214]                 })
[17:29:47.214]                 withCallingHandlers({
[17:29:47.214]                   {
[17:29:47.214]                     sample(x, size = 1L)
[17:29:47.214]                   }
[17:29:47.214]                 }, immediateCondition = function(cond) {
[17:29:47.214]                   sendCondition <- ...future.makeSendCondition()
[17:29:47.214]                   sendCondition(cond)
[17:29:47.214]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.214]                   {
[17:29:47.214]                     inherits <- base::inherits
[17:29:47.214]                     invokeRestart <- base::invokeRestart
[17:29:47.214]                     is.null <- base::is.null
[17:29:47.214]                     muffled <- FALSE
[17:29:47.214]                     if (inherits(cond, "message")) {
[17:29:47.214]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:47.214]                       if (muffled) 
[17:29:47.214]                         invokeRestart("muffleMessage")
[17:29:47.214]                     }
[17:29:47.214]                     else if (inherits(cond, "warning")) {
[17:29:47.214]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:47.214]                       if (muffled) 
[17:29:47.214]                         invokeRestart("muffleWarning")
[17:29:47.214]                     }
[17:29:47.214]                     else if (inherits(cond, "condition")) {
[17:29:47.214]                       if (!is.null(pattern)) {
[17:29:47.214]                         computeRestarts <- base::computeRestarts
[17:29:47.214]                         grepl <- base::grepl
[17:29:47.214]                         restarts <- computeRestarts(cond)
[17:29:47.214]                         for (restart in restarts) {
[17:29:47.214]                           name <- restart$name
[17:29:47.214]                           if (is.null(name)) 
[17:29:47.214]                             next
[17:29:47.214]                           if (!grepl(pattern, name)) 
[17:29:47.214]                             next
[17:29:47.214]                           invokeRestart(restart)
[17:29:47.214]                           muffled <- TRUE
[17:29:47.214]                           break
[17:29:47.214]                         }
[17:29:47.214]                       }
[17:29:47.214]                     }
[17:29:47.214]                     invisible(muffled)
[17:29:47.214]                   }
[17:29:47.214]                   muffleCondition(cond)
[17:29:47.214]                 })
[17:29:47.214]             }))
[17:29:47.214]             future::FutureResult(value = ...future.value$value, 
[17:29:47.214]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.214]                   ...future.rng), globalenv = if (FALSE) 
[17:29:47.214]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:47.214]                     ...future.globalenv.names))
[17:29:47.214]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:47.214]         }, condition = base::local({
[17:29:47.214]             c <- base::c
[17:29:47.214]             inherits <- base::inherits
[17:29:47.214]             invokeRestart <- base::invokeRestart
[17:29:47.214]             length <- base::length
[17:29:47.214]             list <- base::list
[17:29:47.214]             seq.int <- base::seq.int
[17:29:47.214]             signalCondition <- base::signalCondition
[17:29:47.214]             sys.calls <- base::sys.calls
[17:29:47.214]             `[[` <- base::`[[`
[17:29:47.214]             `+` <- base::`+`
[17:29:47.214]             `<<-` <- base::`<<-`
[17:29:47.214]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:47.214]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:47.214]                   3L)]
[17:29:47.214]             }
[17:29:47.214]             function(cond) {
[17:29:47.214]                 is_error <- inherits(cond, "error")
[17:29:47.214]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:47.214]                   NULL)
[17:29:47.214]                 if (is_error) {
[17:29:47.214]                   sessionInformation <- function() {
[17:29:47.214]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:47.214]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:47.214]                       search = base::search(), system = base::Sys.info())
[17:29:47.214]                   }
[17:29:47.214]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.214]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:47.214]                     cond$call), session = sessionInformation(), 
[17:29:47.214]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:47.214]                   signalCondition(cond)
[17:29:47.214]                 }
[17:29:47.214]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:47.214]                 "immediateCondition"))) {
[17:29:47.214]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:47.214]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.214]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:47.214]                   if (TRUE && !signal) {
[17:29:47.214]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.214]                     {
[17:29:47.214]                       inherits <- base::inherits
[17:29:47.214]                       invokeRestart <- base::invokeRestart
[17:29:47.214]                       is.null <- base::is.null
[17:29:47.214]                       muffled <- FALSE
[17:29:47.214]                       if (inherits(cond, "message")) {
[17:29:47.214]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.214]                         if (muffled) 
[17:29:47.214]                           invokeRestart("muffleMessage")
[17:29:47.214]                       }
[17:29:47.214]                       else if (inherits(cond, "warning")) {
[17:29:47.214]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.214]                         if (muffled) 
[17:29:47.214]                           invokeRestart("muffleWarning")
[17:29:47.214]                       }
[17:29:47.214]                       else if (inherits(cond, "condition")) {
[17:29:47.214]                         if (!is.null(pattern)) {
[17:29:47.214]                           computeRestarts <- base::computeRestarts
[17:29:47.214]                           grepl <- base::grepl
[17:29:47.214]                           restarts <- computeRestarts(cond)
[17:29:47.214]                           for (restart in restarts) {
[17:29:47.214]                             name <- restart$name
[17:29:47.214]                             if (is.null(name)) 
[17:29:47.214]                               next
[17:29:47.214]                             if (!grepl(pattern, name)) 
[17:29:47.214]                               next
[17:29:47.214]                             invokeRestart(restart)
[17:29:47.214]                             muffled <- TRUE
[17:29:47.214]                             break
[17:29:47.214]                           }
[17:29:47.214]                         }
[17:29:47.214]                       }
[17:29:47.214]                       invisible(muffled)
[17:29:47.214]                     }
[17:29:47.214]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.214]                   }
[17:29:47.214]                 }
[17:29:47.214]                 else {
[17:29:47.214]                   if (TRUE) {
[17:29:47.214]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.214]                     {
[17:29:47.214]                       inherits <- base::inherits
[17:29:47.214]                       invokeRestart <- base::invokeRestart
[17:29:47.214]                       is.null <- base::is.null
[17:29:47.214]                       muffled <- FALSE
[17:29:47.214]                       if (inherits(cond, "message")) {
[17:29:47.214]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.214]                         if (muffled) 
[17:29:47.214]                           invokeRestart("muffleMessage")
[17:29:47.214]                       }
[17:29:47.214]                       else if (inherits(cond, "warning")) {
[17:29:47.214]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.214]                         if (muffled) 
[17:29:47.214]                           invokeRestart("muffleWarning")
[17:29:47.214]                       }
[17:29:47.214]                       else if (inherits(cond, "condition")) {
[17:29:47.214]                         if (!is.null(pattern)) {
[17:29:47.214]                           computeRestarts <- base::computeRestarts
[17:29:47.214]                           grepl <- base::grepl
[17:29:47.214]                           restarts <- computeRestarts(cond)
[17:29:47.214]                           for (restart in restarts) {
[17:29:47.214]                             name <- restart$name
[17:29:47.214]                             if (is.null(name)) 
[17:29:47.214]                               next
[17:29:47.214]                             if (!grepl(pattern, name)) 
[17:29:47.214]                               next
[17:29:47.214]                             invokeRestart(restart)
[17:29:47.214]                             muffled <- TRUE
[17:29:47.214]                             break
[17:29:47.214]                           }
[17:29:47.214]                         }
[17:29:47.214]                       }
[17:29:47.214]                       invisible(muffled)
[17:29:47.214]                     }
[17:29:47.214]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.214]                   }
[17:29:47.214]                 }
[17:29:47.214]             }
[17:29:47.214]         }))
[17:29:47.214]     }, error = function(ex) {
[17:29:47.214]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:47.214]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.214]                 ...future.rng), started = ...future.startTime, 
[17:29:47.214]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:47.214]             version = "1.8"), class = "FutureResult")
[17:29:47.214]     }, finally = {
[17:29:47.214]         if (!identical(...future.workdir, getwd())) 
[17:29:47.214]             setwd(...future.workdir)
[17:29:47.214]         {
[17:29:47.214]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:47.214]                 ...future.oldOptions$nwarnings <- NULL
[17:29:47.214]             }
[17:29:47.214]             base::options(...future.oldOptions)
[17:29:47.214]             if (.Platform$OS.type == "windows") {
[17:29:47.214]                 old_names <- names(...future.oldEnvVars)
[17:29:47.214]                 envs <- base::Sys.getenv()
[17:29:47.214]                 names <- names(envs)
[17:29:47.214]                 common <- intersect(names, old_names)
[17:29:47.214]                 added <- setdiff(names, old_names)
[17:29:47.214]                 removed <- setdiff(old_names, names)
[17:29:47.214]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:47.214]                   envs[common]]
[17:29:47.214]                 NAMES <- toupper(changed)
[17:29:47.214]                 args <- list()
[17:29:47.214]                 for (kk in seq_along(NAMES)) {
[17:29:47.214]                   name <- changed[[kk]]
[17:29:47.214]                   NAME <- NAMES[[kk]]
[17:29:47.214]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.214]                     next
[17:29:47.214]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.214]                 }
[17:29:47.214]                 NAMES <- toupper(added)
[17:29:47.214]                 for (kk in seq_along(NAMES)) {
[17:29:47.214]                   name <- added[[kk]]
[17:29:47.214]                   NAME <- NAMES[[kk]]
[17:29:47.214]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.214]                     next
[17:29:47.214]                   args[[name]] <- ""
[17:29:47.214]                 }
[17:29:47.214]                 NAMES <- toupper(removed)
[17:29:47.214]                 for (kk in seq_along(NAMES)) {
[17:29:47.214]                   name <- removed[[kk]]
[17:29:47.214]                   NAME <- NAMES[[kk]]
[17:29:47.214]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.214]                     next
[17:29:47.214]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.214]                 }
[17:29:47.214]                 if (length(args) > 0) 
[17:29:47.214]                   base::do.call(base::Sys.setenv, args = args)
[17:29:47.214]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:47.214]             }
[17:29:47.214]             else {
[17:29:47.214]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:47.214]             }
[17:29:47.214]             {
[17:29:47.214]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:47.214]                   0L) {
[17:29:47.214]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:47.214]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:47.214]                   base::options(opts)
[17:29:47.214]                 }
[17:29:47.214]                 {
[17:29:47.214]                   {
[17:29:47.214]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:47.214]                     NULL
[17:29:47.214]                   }
[17:29:47.214]                   options(future.plan = NULL)
[17:29:47.214]                   if (is.na(NA_character_)) 
[17:29:47.214]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.214]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:47.214]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:47.214]                     .init = FALSE)
[17:29:47.214]                 }
[17:29:47.214]             }
[17:29:47.214]         }
[17:29:47.214]     })
[17:29:47.214]     if (TRUE) {
[17:29:47.214]         base::sink(type = "output", split = FALSE)
[17:29:47.214]         if (TRUE) {
[17:29:47.214]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:47.214]         }
[17:29:47.214]         else {
[17:29:47.214]             ...future.result["stdout"] <- base::list(NULL)
[17:29:47.214]         }
[17:29:47.214]         base::close(...future.stdout)
[17:29:47.214]         ...future.stdout <- NULL
[17:29:47.214]     }
[17:29:47.214]     ...future.result$conditions <- ...future.conditions
[17:29:47.214]     ...future.result$finished <- base::Sys.time()
[17:29:47.214]     ...future.result
[17:29:47.214] }
[17:29:47.220] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:47.239] receiveMessageFromWorker() for ClusterFuture ...
[17:29:47.240] - Validating connection of MultisessionFuture
[17:29:47.240] - received message: FutureResult
[17:29:47.241] - Received FutureResult
[17:29:47.241] - Erased future from FutureRegistry
[17:29:47.241] result() for ClusterFuture ...
[17:29:47.242] - result already collected: FutureResult
[17:29:47.242] result() for ClusterFuture ... done
[17:29:47.242] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:47.243] result() for ClusterFuture ...
[17:29:47.243] - result already collected: FutureResult
[17:29:47.243] result() for ClusterFuture ... done
[17:29:47.243] result() for ClusterFuture ...
[17:29:47.244] - result already collected: FutureResult
[17:29:47.244] result() for ClusterFuture ... done
[17:29:47.246] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:47.246] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:47.247] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:47.248] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:47.249] MultisessionFuture started
[17:29:47.250] - Launch lazy future ... done
[17:29:47.250] run() for 'MultisessionFuture' ... done
[17:29:47.251] getGlobalsAndPackages() ...
[17:29:47.251] Searching for globals...
[17:29:47.253] - globals found: [3] '{', 'sample', 'x'
[17:29:47.253] Searching for globals ... DONE
[17:29:47.254] Resolving globals: FALSE
[17:29:47.254] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:47.255] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:47.255] - globals: [1] 'x'
[17:29:47.255] 
[17:29:47.255] getGlobalsAndPackages() ... DONE
[17:29:47.256] run() for 'Future' ...
[17:29:47.256] - state: 'created'
[17:29:47.256] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:47.277] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:47.278] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:47.278]   - Field: 'node'
[17:29:47.278]   - Field: 'label'
[17:29:47.279]   - Field: 'local'
[17:29:47.279]   - Field: 'owner'
[17:29:47.279]   - Field: 'envir'
[17:29:47.280]   - Field: 'workers'
[17:29:47.280]   - Field: 'packages'
[17:29:47.280]   - Field: 'gc'
[17:29:47.280]   - Field: 'conditions'
[17:29:47.280]   - Field: 'persistent'
[17:29:47.280]   - Field: 'expr'
[17:29:47.281]   - Field: 'uuid'
[17:29:47.281]   - Field: 'seed'
[17:29:47.281]   - Field: 'version'
[17:29:47.281]   - Field: 'result'
[17:29:47.281]   - Field: 'asynchronous'
[17:29:47.281]   - Field: 'calls'
[17:29:47.282]   - Field: 'globals'
[17:29:47.282]   - Field: 'stdout'
[17:29:47.282]   - Field: 'earlySignal'
[17:29:47.282]   - Field: 'lazy'
[17:29:47.282]   - Field: 'state'
[17:29:47.283] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:47.283] - Launch lazy future ...
[17:29:47.283] Packages needed by the future expression (n = 0): <none>
[17:29:47.284] Packages needed by future strategies (n = 0): <none>
[17:29:47.284] {
[17:29:47.284]     {
[17:29:47.284]         {
[17:29:47.284]             ...future.startTime <- base::Sys.time()
[17:29:47.284]             {
[17:29:47.284]                 {
[17:29:47.284]                   {
[17:29:47.284]                     {
[17:29:47.284]                       {
[17:29:47.284]                         base::local({
[17:29:47.284]                           has_future <- base::requireNamespace("future", 
[17:29:47.284]                             quietly = TRUE)
[17:29:47.284]                           if (has_future) {
[17:29:47.284]                             ns <- base::getNamespace("future")
[17:29:47.284]                             version <- ns[[".package"]][["version"]]
[17:29:47.284]                             if (is.null(version)) 
[17:29:47.284]                               version <- utils::packageVersion("future")
[17:29:47.284]                           }
[17:29:47.284]                           else {
[17:29:47.284]                             version <- NULL
[17:29:47.284]                           }
[17:29:47.284]                           if (!has_future || version < "1.8.0") {
[17:29:47.284]                             info <- base::c(r_version = base::gsub("R version ", 
[17:29:47.284]                               "", base::R.version$version.string), 
[17:29:47.284]                               platform = base::sprintf("%s (%s-bit)", 
[17:29:47.284]                                 base::R.version$platform, 8 * 
[17:29:47.284]                                   base::.Machine$sizeof.pointer), 
[17:29:47.284]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:47.284]                                 "release", "version")], collapse = " "), 
[17:29:47.284]                               hostname = base::Sys.info()[["nodename"]])
[17:29:47.284]                             info <- base::sprintf("%s: %s", base::names(info), 
[17:29:47.284]                               info)
[17:29:47.284]                             info <- base::paste(info, collapse = "; ")
[17:29:47.284]                             if (!has_future) {
[17:29:47.284]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:47.284]                                 info)
[17:29:47.284]                             }
[17:29:47.284]                             else {
[17:29:47.284]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:47.284]                                 info, version)
[17:29:47.284]                             }
[17:29:47.284]                             base::stop(msg)
[17:29:47.284]                           }
[17:29:47.284]                         })
[17:29:47.284]                       }
[17:29:47.284]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:47.284]                       base::options(mc.cores = 1L)
[17:29:47.284]                     }
[17:29:47.284]                     ...future.strategy.old <- future::plan("list")
[17:29:47.284]                     options(future.plan = NULL)
[17:29:47.284]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.284]                     future::plan("default", .cleanup = FALSE, 
[17:29:47.284]                       .init = FALSE)
[17:29:47.284]                   }
[17:29:47.284]                   base::assign(".Random.seed", c(10407L, -860779432L, 
[17:29:47.284]                   1203324979L, -1993452634L, -1372834584L, 704149361L, 
[17:29:47.284]                   1348506385L), envir = base::globalenv(), inherits = FALSE)
[17:29:47.284]                 }
[17:29:47.284]                 ...future.workdir <- getwd()
[17:29:47.284]             }
[17:29:47.284]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:47.284]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:47.284]         }
[17:29:47.284]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:47.284]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:47.284]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:47.284]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:47.284]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:47.284]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:47.284]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:47.284]             base::names(...future.oldOptions))
[17:29:47.284]     }
[17:29:47.284]     if (FALSE) {
[17:29:47.284]     }
[17:29:47.284]     else {
[17:29:47.284]         if (TRUE) {
[17:29:47.284]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:47.284]                 open = "w")
[17:29:47.284]         }
[17:29:47.284]         else {
[17:29:47.284]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:47.284]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:47.284]         }
[17:29:47.284]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:47.284]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:47.284]             base::sink(type = "output", split = FALSE)
[17:29:47.284]             base::close(...future.stdout)
[17:29:47.284]         }, add = TRUE)
[17:29:47.284]     }
[17:29:47.284]     ...future.frame <- base::sys.nframe()
[17:29:47.284]     ...future.conditions <- base::list()
[17:29:47.284]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:47.284]     if (FALSE) {
[17:29:47.284]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:47.284]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:47.284]     }
[17:29:47.284]     ...future.result <- base::tryCatch({
[17:29:47.284]         base::withCallingHandlers({
[17:29:47.284]             ...future.value <- base::withVisible(base::local({
[17:29:47.284]                 ...future.makeSendCondition <- base::local({
[17:29:47.284]                   sendCondition <- NULL
[17:29:47.284]                   function(frame = 1L) {
[17:29:47.284]                     if (is.function(sendCondition)) 
[17:29:47.284]                       return(sendCondition)
[17:29:47.284]                     ns <- getNamespace("parallel")
[17:29:47.284]                     if (exists("sendData", mode = "function", 
[17:29:47.284]                       envir = ns)) {
[17:29:47.284]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:47.284]                         envir = ns)
[17:29:47.284]                       envir <- sys.frame(frame)
[17:29:47.284]                       master <- NULL
[17:29:47.284]                       while (!identical(envir, .GlobalEnv) && 
[17:29:47.284]                         !identical(envir, emptyenv())) {
[17:29:47.284]                         if (exists("master", mode = "list", envir = envir, 
[17:29:47.284]                           inherits = FALSE)) {
[17:29:47.284]                           master <- get("master", mode = "list", 
[17:29:47.284]                             envir = envir, inherits = FALSE)
[17:29:47.284]                           if (inherits(master, c("SOCKnode", 
[17:29:47.284]                             "SOCK0node"))) {
[17:29:47.284]                             sendCondition <<- function(cond) {
[17:29:47.284]                               data <- list(type = "VALUE", value = cond, 
[17:29:47.284]                                 success = TRUE)
[17:29:47.284]                               parallel_sendData(master, data)
[17:29:47.284]                             }
[17:29:47.284]                             return(sendCondition)
[17:29:47.284]                           }
[17:29:47.284]                         }
[17:29:47.284]                         frame <- frame + 1L
[17:29:47.284]                         envir <- sys.frame(frame)
[17:29:47.284]                       }
[17:29:47.284]                     }
[17:29:47.284]                     sendCondition <<- function(cond) NULL
[17:29:47.284]                   }
[17:29:47.284]                 })
[17:29:47.284]                 withCallingHandlers({
[17:29:47.284]                   {
[17:29:47.284]                     sample(x, size = 1L)
[17:29:47.284]                   }
[17:29:47.284]                 }, immediateCondition = function(cond) {
[17:29:47.284]                   sendCondition <- ...future.makeSendCondition()
[17:29:47.284]                   sendCondition(cond)
[17:29:47.284]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.284]                   {
[17:29:47.284]                     inherits <- base::inherits
[17:29:47.284]                     invokeRestart <- base::invokeRestart
[17:29:47.284]                     is.null <- base::is.null
[17:29:47.284]                     muffled <- FALSE
[17:29:47.284]                     if (inherits(cond, "message")) {
[17:29:47.284]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:47.284]                       if (muffled) 
[17:29:47.284]                         invokeRestart("muffleMessage")
[17:29:47.284]                     }
[17:29:47.284]                     else if (inherits(cond, "warning")) {
[17:29:47.284]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:47.284]                       if (muffled) 
[17:29:47.284]                         invokeRestart("muffleWarning")
[17:29:47.284]                     }
[17:29:47.284]                     else if (inherits(cond, "condition")) {
[17:29:47.284]                       if (!is.null(pattern)) {
[17:29:47.284]                         computeRestarts <- base::computeRestarts
[17:29:47.284]                         grepl <- base::grepl
[17:29:47.284]                         restarts <- computeRestarts(cond)
[17:29:47.284]                         for (restart in restarts) {
[17:29:47.284]                           name <- restart$name
[17:29:47.284]                           if (is.null(name)) 
[17:29:47.284]                             next
[17:29:47.284]                           if (!grepl(pattern, name)) 
[17:29:47.284]                             next
[17:29:47.284]                           invokeRestart(restart)
[17:29:47.284]                           muffled <- TRUE
[17:29:47.284]                           break
[17:29:47.284]                         }
[17:29:47.284]                       }
[17:29:47.284]                     }
[17:29:47.284]                     invisible(muffled)
[17:29:47.284]                   }
[17:29:47.284]                   muffleCondition(cond)
[17:29:47.284]                 })
[17:29:47.284]             }))
[17:29:47.284]             future::FutureResult(value = ...future.value$value, 
[17:29:47.284]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.284]                   ...future.rng), globalenv = if (FALSE) 
[17:29:47.284]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:47.284]                     ...future.globalenv.names))
[17:29:47.284]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:47.284]         }, condition = base::local({
[17:29:47.284]             c <- base::c
[17:29:47.284]             inherits <- base::inherits
[17:29:47.284]             invokeRestart <- base::invokeRestart
[17:29:47.284]             length <- base::length
[17:29:47.284]             list <- base::list
[17:29:47.284]             seq.int <- base::seq.int
[17:29:47.284]             signalCondition <- base::signalCondition
[17:29:47.284]             sys.calls <- base::sys.calls
[17:29:47.284]             `[[` <- base::`[[`
[17:29:47.284]             `+` <- base::`+`
[17:29:47.284]             `<<-` <- base::`<<-`
[17:29:47.284]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:47.284]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:47.284]                   3L)]
[17:29:47.284]             }
[17:29:47.284]             function(cond) {
[17:29:47.284]                 is_error <- inherits(cond, "error")
[17:29:47.284]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:47.284]                   NULL)
[17:29:47.284]                 if (is_error) {
[17:29:47.284]                   sessionInformation <- function() {
[17:29:47.284]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:47.284]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:47.284]                       search = base::search(), system = base::Sys.info())
[17:29:47.284]                   }
[17:29:47.284]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.284]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:47.284]                     cond$call), session = sessionInformation(), 
[17:29:47.284]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:47.284]                   signalCondition(cond)
[17:29:47.284]                 }
[17:29:47.284]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:47.284]                 "immediateCondition"))) {
[17:29:47.284]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:47.284]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.284]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:47.284]                   if (TRUE && !signal) {
[17:29:47.284]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.284]                     {
[17:29:47.284]                       inherits <- base::inherits
[17:29:47.284]                       invokeRestart <- base::invokeRestart
[17:29:47.284]                       is.null <- base::is.null
[17:29:47.284]                       muffled <- FALSE
[17:29:47.284]                       if (inherits(cond, "message")) {
[17:29:47.284]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.284]                         if (muffled) 
[17:29:47.284]                           invokeRestart("muffleMessage")
[17:29:47.284]                       }
[17:29:47.284]                       else if (inherits(cond, "warning")) {
[17:29:47.284]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.284]                         if (muffled) 
[17:29:47.284]                           invokeRestart("muffleWarning")
[17:29:47.284]                       }
[17:29:47.284]                       else if (inherits(cond, "condition")) {
[17:29:47.284]                         if (!is.null(pattern)) {
[17:29:47.284]                           computeRestarts <- base::computeRestarts
[17:29:47.284]                           grepl <- base::grepl
[17:29:47.284]                           restarts <- computeRestarts(cond)
[17:29:47.284]                           for (restart in restarts) {
[17:29:47.284]                             name <- restart$name
[17:29:47.284]                             if (is.null(name)) 
[17:29:47.284]                               next
[17:29:47.284]                             if (!grepl(pattern, name)) 
[17:29:47.284]                               next
[17:29:47.284]                             invokeRestart(restart)
[17:29:47.284]                             muffled <- TRUE
[17:29:47.284]                             break
[17:29:47.284]                           }
[17:29:47.284]                         }
[17:29:47.284]                       }
[17:29:47.284]                       invisible(muffled)
[17:29:47.284]                     }
[17:29:47.284]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.284]                   }
[17:29:47.284]                 }
[17:29:47.284]                 else {
[17:29:47.284]                   if (TRUE) {
[17:29:47.284]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.284]                     {
[17:29:47.284]                       inherits <- base::inherits
[17:29:47.284]                       invokeRestart <- base::invokeRestart
[17:29:47.284]                       is.null <- base::is.null
[17:29:47.284]                       muffled <- FALSE
[17:29:47.284]                       if (inherits(cond, "message")) {
[17:29:47.284]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.284]                         if (muffled) 
[17:29:47.284]                           invokeRestart("muffleMessage")
[17:29:47.284]                       }
[17:29:47.284]                       else if (inherits(cond, "warning")) {
[17:29:47.284]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.284]                         if (muffled) 
[17:29:47.284]                           invokeRestart("muffleWarning")
[17:29:47.284]                       }
[17:29:47.284]                       else if (inherits(cond, "condition")) {
[17:29:47.284]                         if (!is.null(pattern)) {
[17:29:47.284]                           computeRestarts <- base::computeRestarts
[17:29:47.284]                           grepl <- base::grepl
[17:29:47.284]                           restarts <- computeRestarts(cond)
[17:29:47.284]                           for (restart in restarts) {
[17:29:47.284]                             name <- restart$name
[17:29:47.284]                             if (is.null(name)) 
[17:29:47.284]                               next
[17:29:47.284]                             if (!grepl(pattern, name)) 
[17:29:47.284]                               next
[17:29:47.284]                             invokeRestart(restart)
[17:29:47.284]                             muffled <- TRUE
[17:29:47.284]                             break
[17:29:47.284]                           }
[17:29:47.284]                         }
[17:29:47.284]                       }
[17:29:47.284]                       invisible(muffled)
[17:29:47.284]                     }
[17:29:47.284]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.284]                   }
[17:29:47.284]                 }
[17:29:47.284]             }
[17:29:47.284]         }))
[17:29:47.284]     }, error = function(ex) {
[17:29:47.284]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:47.284]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.284]                 ...future.rng), started = ...future.startTime, 
[17:29:47.284]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:47.284]             version = "1.8"), class = "FutureResult")
[17:29:47.284]     }, finally = {
[17:29:47.284]         if (!identical(...future.workdir, getwd())) 
[17:29:47.284]             setwd(...future.workdir)
[17:29:47.284]         {
[17:29:47.284]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:47.284]                 ...future.oldOptions$nwarnings <- NULL
[17:29:47.284]             }
[17:29:47.284]             base::options(...future.oldOptions)
[17:29:47.284]             if (.Platform$OS.type == "windows") {
[17:29:47.284]                 old_names <- names(...future.oldEnvVars)
[17:29:47.284]                 envs <- base::Sys.getenv()
[17:29:47.284]                 names <- names(envs)
[17:29:47.284]                 common <- intersect(names, old_names)
[17:29:47.284]                 added <- setdiff(names, old_names)
[17:29:47.284]                 removed <- setdiff(old_names, names)
[17:29:47.284]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:47.284]                   envs[common]]
[17:29:47.284]                 NAMES <- toupper(changed)
[17:29:47.284]                 args <- list()
[17:29:47.284]                 for (kk in seq_along(NAMES)) {
[17:29:47.284]                   name <- changed[[kk]]
[17:29:47.284]                   NAME <- NAMES[[kk]]
[17:29:47.284]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.284]                     next
[17:29:47.284]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.284]                 }
[17:29:47.284]                 NAMES <- toupper(added)
[17:29:47.284]                 for (kk in seq_along(NAMES)) {
[17:29:47.284]                   name <- added[[kk]]
[17:29:47.284]                   NAME <- NAMES[[kk]]
[17:29:47.284]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.284]                     next
[17:29:47.284]                   args[[name]] <- ""
[17:29:47.284]                 }
[17:29:47.284]                 NAMES <- toupper(removed)
[17:29:47.284]                 for (kk in seq_along(NAMES)) {
[17:29:47.284]                   name <- removed[[kk]]
[17:29:47.284]                   NAME <- NAMES[[kk]]
[17:29:47.284]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.284]                     next
[17:29:47.284]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.284]                 }
[17:29:47.284]                 if (length(args) > 0) 
[17:29:47.284]                   base::do.call(base::Sys.setenv, args = args)
[17:29:47.284]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:47.284]             }
[17:29:47.284]             else {
[17:29:47.284]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:47.284]             }
[17:29:47.284]             {
[17:29:47.284]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:47.284]                   0L) {
[17:29:47.284]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:47.284]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:47.284]                   base::options(opts)
[17:29:47.284]                 }
[17:29:47.284]                 {
[17:29:47.284]                   {
[17:29:47.284]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:47.284]                     NULL
[17:29:47.284]                   }
[17:29:47.284]                   options(future.plan = NULL)
[17:29:47.284]                   if (is.na(NA_character_)) 
[17:29:47.284]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.284]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:47.284]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:47.284]                     .init = FALSE)
[17:29:47.284]                 }
[17:29:47.284]             }
[17:29:47.284]         }
[17:29:47.284]     })
[17:29:47.284]     if (TRUE) {
[17:29:47.284]         base::sink(type = "output", split = FALSE)
[17:29:47.284]         if (TRUE) {
[17:29:47.284]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:47.284]         }
[17:29:47.284]         else {
[17:29:47.284]             ...future.result["stdout"] <- base::list(NULL)
[17:29:47.284]         }
[17:29:47.284]         base::close(...future.stdout)
[17:29:47.284]         ...future.stdout <- NULL
[17:29:47.284]     }
[17:29:47.284]     ...future.result$conditions <- ...future.conditions
[17:29:47.284]     ...future.result$finished <- base::Sys.time()
[17:29:47.284]     ...future.result
[17:29:47.284] }
[17:29:47.290] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:47.316] receiveMessageFromWorker() for ClusterFuture ...
[17:29:47.317] - Validating connection of MultisessionFuture
[17:29:47.317] - received message: FutureResult
[17:29:47.317] - Received FutureResult
[17:29:47.318] - Erased future from FutureRegistry
[17:29:47.318] result() for ClusterFuture ...
[17:29:47.318] - result already collected: FutureResult
[17:29:47.318] result() for ClusterFuture ... done
[17:29:47.318] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:47.319] result() for ClusterFuture ...
[17:29:47.319] - result already collected: FutureResult
[17:29:47.319] result() for ClusterFuture ... done
[17:29:47.319] result() for ClusterFuture ...
[17:29:47.319] - result already collected: FutureResult
[17:29:47.319] result() for ClusterFuture ... done
[17:29:47.321] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:47.321] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:47.321] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:47.321] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:47.322] MultisessionFuture started
[17:29:47.322] - Launch lazy future ... done
[17:29:47.323] run() for 'MultisessionFuture' ... done
[17:29:47.323] result() for ClusterFuture ...
[17:29:47.323] - result already collected: FutureResult
[17:29:47.323] result() for ClusterFuture ... done
[17:29:47.323] result() for ClusterFuture ...
[17:29:47.324] - result already collected: FutureResult
[17:29:47.324] result() for ClusterFuture ... done
[17:29:47.324] result() for ClusterFuture ...
[17:29:47.324] - result already collected: FutureResult
[17:29:47.324] result() for ClusterFuture ... done
[17:29:47.325] result() for ClusterFuture ...
[17:29:47.325] - result already collected: FutureResult
[17:29:47.325] result() for ClusterFuture ... done
[17:29:47.325] result() for ClusterFuture ...
[17:29:47.325] receiveMessageFromWorker() for ClusterFuture ...
[17:29:47.325] - Validating connection of MultisessionFuture
[17:29:47.326] - received message: FutureResult
[17:29:47.326] - Received FutureResult
[17:29:47.326] - Erased future from FutureRegistry
[17:29:47.326] result() for ClusterFuture ...
[17:29:47.326] - result already collected: FutureResult
[17:29:47.327] result() for ClusterFuture ... done
[17:29:47.327] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:47.327] result() for ClusterFuture ... done
[17:29:47.327] result() for ClusterFuture ...
[17:29:47.327] - result already collected: FutureResult
[17:29:47.327] result() for ClusterFuture ... done
[17:29:47.328] result() for ClusterFuture ...
[17:29:47.328] receiveMessageFromWorker() for ClusterFuture ...
[17:29:47.328] - Validating connection of MultisessionFuture
[17:29:47.340] - received message: FutureResult
[17:29:47.340] - Received FutureResult
[17:29:47.341] - Erased future from FutureRegistry
[17:29:47.341] result() for ClusterFuture ...
[17:29:47.341] - result already collected: FutureResult
[17:29:47.341] result() for ClusterFuture ... done
[17:29:47.341] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:47.341] result() for ClusterFuture ... done
[17:29:47.341] result() for ClusterFuture ...
[17:29:47.342] - result already collected: FutureResult
[17:29:47.342] result() for ClusterFuture ... done
[[1]]
[1] 2

[[2]]
[1] 0

[[3]]
[1] 0

[[4]]
[1] 1

[17:29:47.343] getGlobalsAndPackages() ...
[17:29:47.343] Searching for globals...
[17:29:47.344] - globals found: [3] '{', 'sample', 'x'
[17:29:47.344] Searching for globals ... DONE
[17:29:47.344] Resolving globals: FALSE
[17:29:47.345] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:47.345] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:47.345] - globals: [1] 'x'
[17:29:47.346] 
[17:29:47.346] getGlobalsAndPackages() ... DONE
[17:29:47.346] run() for 'Future' ...
[17:29:47.346] - state: 'created'
[17:29:47.346] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:47.360] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:47.360] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:47.360]   - Field: 'node'
[17:29:47.361]   - Field: 'label'
[17:29:47.361]   - Field: 'local'
[17:29:47.361]   - Field: 'owner'
[17:29:47.361]   - Field: 'envir'
[17:29:47.361]   - Field: 'workers'
[17:29:47.361]   - Field: 'packages'
[17:29:47.362]   - Field: 'gc'
[17:29:47.362]   - Field: 'conditions'
[17:29:47.362]   - Field: 'persistent'
[17:29:47.362]   - Field: 'expr'
[17:29:47.362]   - Field: 'uuid'
[17:29:47.363]   - Field: 'seed'
[17:29:47.363]   - Field: 'version'
[17:29:47.363]   - Field: 'result'
[17:29:47.363]   - Field: 'asynchronous'
[17:29:47.363]   - Field: 'calls'
[17:29:47.363]   - Field: 'globals'
[17:29:47.364]   - Field: 'stdout'
[17:29:47.364]   - Field: 'earlySignal'
[17:29:47.364]   - Field: 'lazy'
[17:29:47.364]   - Field: 'state'
[17:29:47.364] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:47.364] - Launch lazy future ...
[17:29:47.365] Packages needed by the future expression (n = 0): <none>
[17:29:47.365] Packages needed by future strategies (n = 0): <none>
[17:29:47.365] {
[17:29:47.365]     {
[17:29:47.365]         {
[17:29:47.365]             ...future.startTime <- base::Sys.time()
[17:29:47.365]             {
[17:29:47.365]                 {
[17:29:47.365]                   {
[17:29:47.365]                     {
[17:29:47.365]                       base::local({
[17:29:47.365]                         has_future <- base::requireNamespace("future", 
[17:29:47.365]                           quietly = TRUE)
[17:29:47.365]                         if (has_future) {
[17:29:47.365]                           ns <- base::getNamespace("future")
[17:29:47.365]                           version <- ns[[".package"]][["version"]]
[17:29:47.365]                           if (is.null(version)) 
[17:29:47.365]                             version <- utils::packageVersion("future")
[17:29:47.365]                         }
[17:29:47.365]                         else {
[17:29:47.365]                           version <- NULL
[17:29:47.365]                         }
[17:29:47.365]                         if (!has_future || version < "1.8.0") {
[17:29:47.365]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:47.365]                             "", base::R.version$version.string), 
[17:29:47.365]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:47.365]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:47.365]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:47.365]                               "release", "version")], collapse = " "), 
[17:29:47.365]                             hostname = base::Sys.info()[["nodename"]])
[17:29:47.365]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:47.365]                             info)
[17:29:47.365]                           info <- base::paste(info, collapse = "; ")
[17:29:47.365]                           if (!has_future) {
[17:29:47.365]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:47.365]                               info)
[17:29:47.365]                           }
[17:29:47.365]                           else {
[17:29:47.365]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:47.365]                               info, version)
[17:29:47.365]                           }
[17:29:47.365]                           base::stop(msg)
[17:29:47.365]                         }
[17:29:47.365]                       })
[17:29:47.365]                     }
[17:29:47.365]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:47.365]                     base::options(mc.cores = 1L)
[17:29:47.365]                   }
[17:29:47.365]                   ...future.strategy.old <- future::plan("list")
[17:29:47.365]                   options(future.plan = NULL)
[17:29:47.365]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.365]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:47.365]                 }
[17:29:47.365]                 ...future.workdir <- getwd()
[17:29:47.365]             }
[17:29:47.365]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:47.365]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:47.365]         }
[17:29:47.365]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:47.365]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:47.365]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:47.365]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:47.365]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:47.365]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:47.365]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:47.365]             base::names(...future.oldOptions))
[17:29:47.365]     }
[17:29:47.365]     if (FALSE) {
[17:29:47.365]     }
[17:29:47.365]     else {
[17:29:47.365]         if (TRUE) {
[17:29:47.365]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:47.365]                 open = "w")
[17:29:47.365]         }
[17:29:47.365]         else {
[17:29:47.365]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:47.365]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:47.365]         }
[17:29:47.365]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:47.365]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:47.365]             base::sink(type = "output", split = FALSE)
[17:29:47.365]             base::close(...future.stdout)
[17:29:47.365]         }, add = TRUE)
[17:29:47.365]     }
[17:29:47.365]     ...future.frame <- base::sys.nframe()
[17:29:47.365]     ...future.conditions <- base::list()
[17:29:47.365]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:47.365]     if (FALSE) {
[17:29:47.365]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:47.365]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:47.365]     }
[17:29:47.365]     ...future.result <- base::tryCatch({
[17:29:47.365]         base::withCallingHandlers({
[17:29:47.365]             ...future.value <- base::withVisible(base::local({
[17:29:47.365]                 ...future.makeSendCondition <- base::local({
[17:29:47.365]                   sendCondition <- NULL
[17:29:47.365]                   function(frame = 1L) {
[17:29:47.365]                     if (is.function(sendCondition)) 
[17:29:47.365]                       return(sendCondition)
[17:29:47.365]                     ns <- getNamespace("parallel")
[17:29:47.365]                     if (exists("sendData", mode = "function", 
[17:29:47.365]                       envir = ns)) {
[17:29:47.365]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:47.365]                         envir = ns)
[17:29:47.365]                       envir <- sys.frame(frame)
[17:29:47.365]                       master <- NULL
[17:29:47.365]                       while (!identical(envir, .GlobalEnv) && 
[17:29:47.365]                         !identical(envir, emptyenv())) {
[17:29:47.365]                         if (exists("master", mode = "list", envir = envir, 
[17:29:47.365]                           inherits = FALSE)) {
[17:29:47.365]                           master <- get("master", mode = "list", 
[17:29:47.365]                             envir = envir, inherits = FALSE)
[17:29:47.365]                           if (inherits(master, c("SOCKnode", 
[17:29:47.365]                             "SOCK0node"))) {
[17:29:47.365]                             sendCondition <<- function(cond) {
[17:29:47.365]                               data <- list(type = "VALUE", value = cond, 
[17:29:47.365]                                 success = TRUE)
[17:29:47.365]                               parallel_sendData(master, data)
[17:29:47.365]                             }
[17:29:47.365]                             return(sendCondition)
[17:29:47.365]                           }
[17:29:47.365]                         }
[17:29:47.365]                         frame <- frame + 1L
[17:29:47.365]                         envir <- sys.frame(frame)
[17:29:47.365]                       }
[17:29:47.365]                     }
[17:29:47.365]                     sendCondition <<- function(cond) NULL
[17:29:47.365]                   }
[17:29:47.365]                 })
[17:29:47.365]                 withCallingHandlers({
[17:29:47.365]                   {
[17:29:47.365]                     sample(x, size = 1L)
[17:29:47.365]                   }
[17:29:47.365]                 }, immediateCondition = function(cond) {
[17:29:47.365]                   sendCondition <- ...future.makeSendCondition()
[17:29:47.365]                   sendCondition(cond)
[17:29:47.365]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.365]                   {
[17:29:47.365]                     inherits <- base::inherits
[17:29:47.365]                     invokeRestart <- base::invokeRestart
[17:29:47.365]                     is.null <- base::is.null
[17:29:47.365]                     muffled <- FALSE
[17:29:47.365]                     if (inherits(cond, "message")) {
[17:29:47.365]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:47.365]                       if (muffled) 
[17:29:47.365]                         invokeRestart("muffleMessage")
[17:29:47.365]                     }
[17:29:47.365]                     else if (inherits(cond, "warning")) {
[17:29:47.365]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:47.365]                       if (muffled) 
[17:29:47.365]                         invokeRestart("muffleWarning")
[17:29:47.365]                     }
[17:29:47.365]                     else if (inherits(cond, "condition")) {
[17:29:47.365]                       if (!is.null(pattern)) {
[17:29:47.365]                         computeRestarts <- base::computeRestarts
[17:29:47.365]                         grepl <- base::grepl
[17:29:47.365]                         restarts <- computeRestarts(cond)
[17:29:47.365]                         for (restart in restarts) {
[17:29:47.365]                           name <- restart$name
[17:29:47.365]                           if (is.null(name)) 
[17:29:47.365]                             next
[17:29:47.365]                           if (!grepl(pattern, name)) 
[17:29:47.365]                             next
[17:29:47.365]                           invokeRestart(restart)
[17:29:47.365]                           muffled <- TRUE
[17:29:47.365]                           break
[17:29:47.365]                         }
[17:29:47.365]                       }
[17:29:47.365]                     }
[17:29:47.365]                     invisible(muffled)
[17:29:47.365]                   }
[17:29:47.365]                   muffleCondition(cond)
[17:29:47.365]                 })
[17:29:47.365]             }))
[17:29:47.365]             future::FutureResult(value = ...future.value$value, 
[17:29:47.365]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.365]                   ...future.rng), globalenv = if (FALSE) 
[17:29:47.365]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:47.365]                     ...future.globalenv.names))
[17:29:47.365]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:47.365]         }, condition = base::local({
[17:29:47.365]             c <- base::c
[17:29:47.365]             inherits <- base::inherits
[17:29:47.365]             invokeRestart <- base::invokeRestart
[17:29:47.365]             length <- base::length
[17:29:47.365]             list <- base::list
[17:29:47.365]             seq.int <- base::seq.int
[17:29:47.365]             signalCondition <- base::signalCondition
[17:29:47.365]             sys.calls <- base::sys.calls
[17:29:47.365]             `[[` <- base::`[[`
[17:29:47.365]             `+` <- base::`+`
[17:29:47.365]             `<<-` <- base::`<<-`
[17:29:47.365]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:47.365]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:47.365]                   3L)]
[17:29:47.365]             }
[17:29:47.365]             function(cond) {
[17:29:47.365]                 is_error <- inherits(cond, "error")
[17:29:47.365]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:47.365]                   NULL)
[17:29:47.365]                 if (is_error) {
[17:29:47.365]                   sessionInformation <- function() {
[17:29:47.365]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:47.365]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:47.365]                       search = base::search(), system = base::Sys.info())
[17:29:47.365]                   }
[17:29:47.365]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.365]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:47.365]                     cond$call), session = sessionInformation(), 
[17:29:47.365]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:47.365]                   signalCondition(cond)
[17:29:47.365]                 }
[17:29:47.365]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:47.365]                 "immediateCondition"))) {
[17:29:47.365]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:47.365]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.365]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:47.365]                   if (TRUE && !signal) {
[17:29:47.365]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.365]                     {
[17:29:47.365]                       inherits <- base::inherits
[17:29:47.365]                       invokeRestart <- base::invokeRestart
[17:29:47.365]                       is.null <- base::is.null
[17:29:47.365]                       muffled <- FALSE
[17:29:47.365]                       if (inherits(cond, "message")) {
[17:29:47.365]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.365]                         if (muffled) 
[17:29:47.365]                           invokeRestart("muffleMessage")
[17:29:47.365]                       }
[17:29:47.365]                       else if (inherits(cond, "warning")) {
[17:29:47.365]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.365]                         if (muffled) 
[17:29:47.365]                           invokeRestart("muffleWarning")
[17:29:47.365]                       }
[17:29:47.365]                       else if (inherits(cond, "condition")) {
[17:29:47.365]                         if (!is.null(pattern)) {
[17:29:47.365]                           computeRestarts <- base::computeRestarts
[17:29:47.365]                           grepl <- base::grepl
[17:29:47.365]                           restarts <- computeRestarts(cond)
[17:29:47.365]                           for (restart in restarts) {
[17:29:47.365]                             name <- restart$name
[17:29:47.365]                             if (is.null(name)) 
[17:29:47.365]                               next
[17:29:47.365]                             if (!grepl(pattern, name)) 
[17:29:47.365]                               next
[17:29:47.365]                             invokeRestart(restart)
[17:29:47.365]                             muffled <- TRUE
[17:29:47.365]                             break
[17:29:47.365]                           }
[17:29:47.365]                         }
[17:29:47.365]                       }
[17:29:47.365]                       invisible(muffled)
[17:29:47.365]                     }
[17:29:47.365]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.365]                   }
[17:29:47.365]                 }
[17:29:47.365]                 else {
[17:29:47.365]                   if (TRUE) {
[17:29:47.365]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.365]                     {
[17:29:47.365]                       inherits <- base::inherits
[17:29:47.365]                       invokeRestart <- base::invokeRestart
[17:29:47.365]                       is.null <- base::is.null
[17:29:47.365]                       muffled <- FALSE
[17:29:47.365]                       if (inherits(cond, "message")) {
[17:29:47.365]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.365]                         if (muffled) 
[17:29:47.365]                           invokeRestart("muffleMessage")
[17:29:47.365]                       }
[17:29:47.365]                       else if (inherits(cond, "warning")) {
[17:29:47.365]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.365]                         if (muffled) 
[17:29:47.365]                           invokeRestart("muffleWarning")
[17:29:47.365]                       }
[17:29:47.365]                       else if (inherits(cond, "condition")) {
[17:29:47.365]                         if (!is.null(pattern)) {
[17:29:47.365]                           computeRestarts <- base::computeRestarts
[17:29:47.365]                           grepl <- base::grepl
[17:29:47.365]                           restarts <- computeRestarts(cond)
[17:29:47.365]                           for (restart in restarts) {
[17:29:47.365]                             name <- restart$name
[17:29:47.365]                             if (is.null(name)) 
[17:29:47.365]                               next
[17:29:47.365]                             if (!grepl(pattern, name)) 
[17:29:47.365]                               next
[17:29:47.365]                             invokeRestart(restart)
[17:29:47.365]                             muffled <- TRUE
[17:29:47.365]                             break
[17:29:47.365]                           }
[17:29:47.365]                         }
[17:29:47.365]                       }
[17:29:47.365]                       invisible(muffled)
[17:29:47.365]                     }
[17:29:47.365]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.365]                   }
[17:29:47.365]                 }
[17:29:47.365]             }
[17:29:47.365]         }))
[17:29:47.365]     }, error = function(ex) {
[17:29:47.365]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:47.365]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.365]                 ...future.rng), started = ...future.startTime, 
[17:29:47.365]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:47.365]             version = "1.8"), class = "FutureResult")
[17:29:47.365]     }, finally = {
[17:29:47.365]         if (!identical(...future.workdir, getwd())) 
[17:29:47.365]             setwd(...future.workdir)
[17:29:47.365]         {
[17:29:47.365]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:47.365]                 ...future.oldOptions$nwarnings <- NULL
[17:29:47.365]             }
[17:29:47.365]             base::options(...future.oldOptions)
[17:29:47.365]             if (.Platform$OS.type == "windows") {
[17:29:47.365]                 old_names <- names(...future.oldEnvVars)
[17:29:47.365]                 envs <- base::Sys.getenv()
[17:29:47.365]                 names <- names(envs)
[17:29:47.365]                 common <- intersect(names, old_names)
[17:29:47.365]                 added <- setdiff(names, old_names)
[17:29:47.365]                 removed <- setdiff(old_names, names)
[17:29:47.365]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:47.365]                   envs[common]]
[17:29:47.365]                 NAMES <- toupper(changed)
[17:29:47.365]                 args <- list()
[17:29:47.365]                 for (kk in seq_along(NAMES)) {
[17:29:47.365]                   name <- changed[[kk]]
[17:29:47.365]                   NAME <- NAMES[[kk]]
[17:29:47.365]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.365]                     next
[17:29:47.365]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.365]                 }
[17:29:47.365]                 NAMES <- toupper(added)
[17:29:47.365]                 for (kk in seq_along(NAMES)) {
[17:29:47.365]                   name <- added[[kk]]
[17:29:47.365]                   NAME <- NAMES[[kk]]
[17:29:47.365]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.365]                     next
[17:29:47.365]                   args[[name]] <- ""
[17:29:47.365]                 }
[17:29:47.365]                 NAMES <- toupper(removed)
[17:29:47.365]                 for (kk in seq_along(NAMES)) {
[17:29:47.365]                   name <- removed[[kk]]
[17:29:47.365]                   NAME <- NAMES[[kk]]
[17:29:47.365]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.365]                     next
[17:29:47.365]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.365]                 }
[17:29:47.365]                 if (length(args) > 0) 
[17:29:47.365]                   base::do.call(base::Sys.setenv, args = args)
[17:29:47.365]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:47.365]             }
[17:29:47.365]             else {
[17:29:47.365]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:47.365]             }
[17:29:47.365]             {
[17:29:47.365]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:47.365]                   0L) {
[17:29:47.365]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:47.365]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:47.365]                   base::options(opts)
[17:29:47.365]                 }
[17:29:47.365]                 {
[17:29:47.365]                   {
[17:29:47.365]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:47.365]                     NULL
[17:29:47.365]                   }
[17:29:47.365]                   options(future.plan = NULL)
[17:29:47.365]                   if (is.na(NA_character_)) 
[17:29:47.365]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.365]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:47.365]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:47.365]                     .init = FALSE)
[17:29:47.365]                 }
[17:29:47.365]             }
[17:29:47.365]         }
[17:29:47.365]     })
[17:29:47.365]     if (TRUE) {
[17:29:47.365]         base::sink(type = "output", split = FALSE)
[17:29:47.365]         if (TRUE) {
[17:29:47.365]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:47.365]         }
[17:29:47.365]         else {
[17:29:47.365]             ...future.result["stdout"] <- base::list(NULL)
[17:29:47.365]         }
[17:29:47.365]         base::close(...future.stdout)
[17:29:47.365]         ...future.stdout <- NULL
[17:29:47.365]     }
[17:29:47.365]     ...future.result$conditions <- ...future.conditions
[17:29:47.365]     ...future.result$finished <- base::Sys.time()
[17:29:47.365]     ...future.result
[17:29:47.365] }
[17:29:47.370] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:47.371] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:47.371] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:47.371] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:47.372] MultisessionFuture started
[17:29:47.372] - Launch lazy future ... done
[17:29:47.372] run() for 'MultisessionFuture' ... done
[17:29:47.373] getGlobalsAndPackages() ...
[17:29:47.373] Searching for globals...
[17:29:47.374] - globals found: [3] '{', 'sample', 'x'
[17:29:47.374] Searching for globals ... DONE
[17:29:47.374] Resolving globals: FALSE
[17:29:47.375] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:47.375] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:47.375] - globals: [1] 'x'
[17:29:47.376] 
[17:29:47.376] getGlobalsAndPackages() ... DONE
[17:29:47.376] run() for 'Future' ...
[17:29:47.376] - state: 'created'
[17:29:47.377] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:47.390] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:47.391] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:47.391]   - Field: 'node'
[17:29:47.391]   - Field: 'label'
[17:29:47.391]   - Field: 'local'
[17:29:47.391]   - Field: 'owner'
[17:29:47.391]   - Field: 'envir'
[17:29:47.392]   - Field: 'workers'
[17:29:47.392]   - Field: 'packages'
[17:29:47.392]   - Field: 'gc'
[17:29:47.392]   - Field: 'conditions'
[17:29:47.392]   - Field: 'persistent'
[17:29:47.392]   - Field: 'expr'
[17:29:47.392]   - Field: 'uuid'
[17:29:47.393]   - Field: 'seed'
[17:29:47.393]   - Field: 'version'
[17:29:47.393]   - Field: 'result'
[17:29:47.393]   - Field: 'asynchronous'
[17:29:47.393]   - Field: 'calls'
[17:29:47.393]   - Field: 'globals'
[17:29:47.394]   - Field: 'stdout'
[17:29:47.394]   - Field: 'earlySignal'
[17:29:47.394]   - Field: 'lazy'
[17:29:47.394]   - Field: 'state'
[17:29:47.395] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:47.395] - Launch lazy future ...
[17:29:47.395] Packages needed by the future expression (n = 0): <none>
[17:29:47.396] Packages needed by future strategies (n = 0): <none>
[17:29:47.397] {
[17:29:47.397]     {
[17:29:47.397]         {
[17:29:47.397]             ...future.startTime <- base::Sys.time()
[17:29:47.397]             {
[17:29:47.397]                 {
[17:29:47.397]                   {
[17:29:47.397]                     {
[17:29:47.397]                       base::local({
[17:29:47.397]                         has_future <- base::requireNamespace("future", 
[17:29:47.397]                           quietly = TRUE)
[17:29:47.397]                         if (has_future) {
[17:29:47.397]                           ns <- base::getNamespace("future")
[17:29:47.397]                           version <- ns[[".package"]][["version"]]
[17:29:47.397]                           if (is.null(version)) 
[17:29:47.397]                             version <- utils::packageVersion("future")
[17:29:47.397]                         }
[17:29:47.397]                         else {
[17:29:47.397]                           version <- NULL
[17:29:47.397]                         }
[17:29:47.397]                         if (!has_future || version < "1.8.0") {
[17:29:47.397]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:47.397]                             "", base::R.version$version.string), 
[17:29:47.397]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:47.397]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:47.397]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:47.397]                               "release", "version")], collapse = " "), 
[17:29:47.397]                             hostname = base::Sys.info()[["nodename"]])
[17:29:47.397]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:47.397]                             info)
[17:29:47.397]                           info <- base::paste(info, collapse = "; ")
[17:29:47.397]                           if (!has_future) {
[17:29:47.397]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:47.397]                               info)
[17:29:47.397]                           }
[17:29:47.397]                           else {
[17:29:47.397]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:47.397]                               info, version)
[17:29:47.397]                           }
[17:29:47.397]                           base::stop(msg)
[17:29:47.397]                         }
[17:29:47.397]                       })
[17:29:47.397]                     }
[17:29:47.397]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:47.397]                     base::options(mc.cores = 1L)
[17:29:47.397]                   }
[17:29:47.397]                   ...future.strategy.old <- future::plan("list")
[17:29:47.397]                   options(future.plan = NULL)
[17:29:47.397]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.397]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:47.397]                 }
[17:29:47.397]                 ...future.workdir <- getwd()
[17:29:47.397]             }
[17:29:47.397]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:47.397]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:47.397]         }
[17:29:47.397]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:47.397]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:47.397]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:47.397]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:47.397]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:47.397]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:47.397]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:47.397]             base::names(...future.oldOptions))
[17:29:47.397]     }
[17:29:47.397]     if (FALSE) {
[17:29:47.397]     }
[17:29:47.397]     else {
[17:29:47.397]         if (TRUE) {
[17:29:47.397]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:47.397]                 open = "w")
[17:29:47.397]         }
[17:29:47.397]         else {
[17:29:47.397]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:47.397]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:47.397]         }
[17:29:47.397]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:47.397]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:47.397]             base::sink(type = "output", split = FALSE)
[17:29:47.397]             base::close(...future.stdout)
[17:29:47.397]         }, add = TRUE)
[17:29:47.397]     }
[17:29:47.397]     ...future.frame <- base::sys.nframe()
[17:29:47.397]     ...future.conditions <- base::list()
[17:29:47.397]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:47.397]     if (FALSE) {
[17:29:47.397]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:47.397]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:47.397]     }
[17:29:47.397]     ...future.result <- base::tryCatch({
[17:29:47.397]         base::withCallingHandlers({
[17:29:47.397]             ...future.value <- base::withVisible(base::local({
[17:29:47.397]                 ...future.makeSendCondition <- base::local({
[17:29:47.397]                   sendCondition <- NULL
[17:29:47.397]                   function(frame = 1L) {
[17:29:47.397]                     if (is.function(sendCondition)) 
[17:29:47.397]                       return(sendCondition)
[17:29:47.397]                     ns <- getNamespace("parallel")
[17:29:47.397]                     if (exists("sendData", mode = "function", 
[17:29:47.397]                       envir = ns)) {
[17:29:47.397]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:47.397]                         envir = ns)
[17:29:47.397]                       envir <- sys.frame(frame)
[17:29:47.397]                       master <- NULL
[17:29:47.397]                       while (!identical(envir, .GlobalEnv) && 
[17:29:47.397]                         !identical(envir, emptyenv())) {
[17:29:47.397]                         if (exists("master", mode = "list", envir = envir, 
[17:29:47.397]                           inherits = FALSE)) {
[17:29:47.397]                           master <- get("master", mode = "list", 
[17:29:47.397]                             envir = envir, inherits = FALSE)
[17:29:47.397]                           if (inherits(master, c("SOCKnode", 
[17:29:47.397]                             "SOCK0node"))) {
[17:29:47.397]                             sendCondition <<- function(cond) {
[17:29:47.397]                               data <- list(type = "VALUE", value = cond, 
[17:29:47.397]                                 success = TRUE)
[17:29:47.397]                               parallel_sendData(master, data)
[17:29:47.397]                             }
[17:29:47.397]                             return(sendCondition)
[17:29:47.397]                           }
[17:29:47.397]                         }
[17:29:47.397]                         frame <- frame + 1L
[17:29:47.397]                         envir <- sys.frame(frame)
[17:29:47.397]                       }
[17:29:47.397]                     }
[17:29:47.397]                     sendCondition <<- function(cond) NULL
[17:29:47.397]                   }
[17:29:47.397]                 })
[17:29:47.397]                 withCallingHandlers({
[17:29:47.397]                   {
[17:29:47.397]                     sample(x, size = 1L)
[17:29:47.397]                   }
[17:29:47.397]                 }, immediateCondition = function(cond) {
[17:29:47.397]                   sendCondition <- ...future.makeSendCondition()
[17:29:47.397]                   sendCondition(cond)
[17:29:47.397]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.397]                   {
[17:29:47.397]                     inherits <- base::inherits
[17:29:47.397]                     invokeRestart <- base::invokeRestart
[17:29:47.397]                     is.null <- base::is.null
[17:29:47.397]                     muffled <- FALSE
[17:29:47.397]                     if (inherits(cond, "message")) {
[17:29:47.397]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:47.397]                       if (muffled) 
[17:29:47.397]                         invokeRestart("muffleMessage")
[17:29:47.397]                     }
[17:29:47.397]                     else if (inherits(cond, "warning")) {
[17:29:47.397]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:47.397]                       if (muffled) 
[17:29:47.397]                         invokeRestart("muffleWarning")
[17:29:47.397]                     }
[17:29:47.397]                     else if (inherits(cond, "condition")) {
[17:29:47.397]                       if (!is.null(pattern)) {
[17:29:47.397]                         computeRestarts <- base::computeRestarts
[17:29:47.397]                         grepl <- base::grepl
[17:29:47.397]                         restarts <- computeRestarts(cond)
[17:29:47.397]                         for (restart in restarts) {
[17:29:47.397]                           name <- restart$name
[17:29:47.397]                           if (is.null(name)) 
[17:29:47.397]                             next
[17:29:47.397]                           if (!grepl(pattern, name)) 
[17:29:47.397]                             next
[17:29:47.397]                           invokeRestart(restart)
[17:29:47.397]                           muffled <- TRUE
[17:29:47.397]                           break
[17:29:47.397]                         }
[17:29:47.397]                       }
[17:29:47.397]                     }
[17:29:47.397]                     invisible(muffled)
[17:29:47.397]                   }
[17:29:47.397]                   muffleCondition(cond)
[17:29:47.397]                 })
[17:29:47.397]             }))
[17:29:47.397]             future::FutureResult(value = ...future.value$value, 
[17:29:47.397]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.397]                   ...future.rng), globalenv = if (FALSE) 
[17:29:47.397]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:47.397]                     ...future.globalenv.names))
[17:29:47.397]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:47.397]         }, condition = base::local({
[17:29:47.397]             c <- base::c
[17:29:47.397]             inherits <- base::inherits
[17:29:47.397]             invokeRestart <- base::invokeRestart
[17:29:47.397]             length <- base::length
[17:29:47.397]             list <- base::list
[17:29:47.397]             seq.int <- base::seq.int
[17:29:47.397]             signalCondition <- base::signalCondition
[17:29:47.397]             sys.calls <- base::sys.calls
[17:29:47.397]             `[[` <- base::`[[`
[17:29:47.397]             `+` <- base::`+`
[17:29:47.397]             `<<-` <- base::`<<-`
[17:29:47.397]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:47.397]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:47.397]                   3L)]
[17:29:47.397]             }
[17:29:47.397]             function(cond) {
[17:29:47.397]                 is_error <- inherits(cond, "error")
[17:29:47.397]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:47.397]                   NULL)
[17:29:47.397]                 if (is_error) {
[17:29:47.397]                   sessionInformation <- function() {
[17:29:47.397]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:47.397]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:47.397]                       search = base::search(), system = base::Sys.info())
[17:29:47.397]                   }
[17:29:47.397]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.397]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:47.397]                     cond$call), session = sessionInformation(), 
[17:29:47.397]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:47.397]                   signalCondition(cond)
[17:29:47.397]                 }
[17:29:47.397]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:47.397]                 "immediateCondition"))) {
[17:29:47.397]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:47.397]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.397]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:47.397]                   if (TRUE && !signal) {
[17:29:47.397]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.397]                     {
[17:29:47.397]                       inherits <- base::inherits
[17:29:47.397]                       invokeRestart <- base::invokeRestart
[17:29:47.397]                       is.null <- base::is.null
[17:29:47.397]                       muffled <- FALSE
[17:29:47.397]                       if (inherits(cond, "message")) {
[17:29:47.397]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.397]                         if (muffled) 
[17:29:47.397]                           invokeRestart("muffleMessage")
[17:29:47.397]                       }
[17:29:47.397]                       else if (inherits(cond, "warning")) {
[17:29:47.397]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.397]                         if (muffled) 
[17:29:47.397]                           invokeRestart("muffleWarning")
[17:29:47.397]                       }
[17:29:47.397]                       else if (inherits(cond, "condition")) {
[17:29:47.397]                         if (!is.null(pattern)) {
[17:29:47.397]                           computeRestarts <- base::computeRestarts
[17:29:47.397]                           grepl <- base::grepl
[17:29:47.397]                           restarts <- computeRestarts(cond)
[17:29:47.397]                           for (restart in restarts) {
[17:29:47.397]                             name <- restart$name
[17:29:47.397]                             if (is.null(name)) 
[17:29:47.397]                               next
[17:29:47.397]                             if (!grepl(pattern, name)) 
[17:29:47.397]                               next
[17:29:47.397]                             invokeRestart(restart)
[17:29:47.397]                             muffled <- TRUE
[17:29:47.397]                             break
[17:29:47.397]                           }
[17:29:47.397]                         }
[17:29:47.397]                       }
[17:29:47.397]                       invisible(muffled)
[17:29:47.397]                     }
[17:29:47.397]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.397]                   }
[17:29:47.397]                 }
[17:29:47.397]                 else {
[17:29:47.397]                   if (TRUE) {
[17:29:47.397]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.397]                     {
[17:29:47.397]                       inherits <- base::inherits
[17:29:47.397]                       invokeRestart <- base::invokeRestart
[17:29:47.397]                       is.null <- base::is.null
[17:29:47.397]                       muffled <- FALSE
[17:29:47.397]                       if (inherits(cond, "message")) {
[17:29:47.397]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.397]                         if (muffled) 
[17:29:47.397]                           invokeRestart("muffleMessage")
[17:29:47.397]                       }
[17:29:47.397]                       else if (inherits(cond, "warning")) {
[17:29:47.397]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.397]                         if (muffled) 
[17:29:47.397]                           invokeRestart("muffleWarning")
[17:29:47.397]                       }
[17:29:47.397]                       else if (inherits(cond, "condition")) {
[17:29:47.397]                         if (!is.null(pattern)) {
[17:29:47.397]                           computeRestarts <- base::computeRestarts
[17:29:47.397]                           grepl <- base::grepl
[17:29:47.397]                           restarts <- computeRestarts(cond)
[17:29:47.397]                           for (restart in restarts) {
[17:29:47.397]                             name <- restart$name
[17:29:47.397]                             if (is.null(name)) 
[17:29:47.397]                               next
[17:29:47.397]                             if (!grepl(pattern, name)) 
[17:29:47.397]                               next
[17:29:47.397]                             invokeRestart(restart)
[17:29:47.397]                             muffled <- TRUE
[17:29:47.397]                             break
[17:29:47.397]                           }
[17:29:47.397]                         }
[17:29:47.397]                       }
[17:29:47.397]                       invisible(muffled)
[17:29:47.397]                     }
[17:29:47.397]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.397]                   }
[17:29:47.397]                 }
[17:29:47.397]             }
[17:29:47.397]         }))
[17:29:47.397]     }, error = function(ex) {
[17:29:47.397]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:47.397]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.397]                 ...future.rng), started = ...future.startTime, 
[17:29:47.397]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:47.397]             version = "1.8"), class = "FutureResult")
[17:29:47.397]     }, finally = {
[17:29:47.397]         if (!identical(...future.workdir, getwd())) 
[17:29:47.397]             setwd(...future.workdir)
[17:29:47.397]         {
[17:29:47.397]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:47.397]                 ...future.oldOptions$nwarnings <- NULL
[17:29:47.397]             }
[17:29:47.397]             base::options(...future.oldOptions)
[17:29:47.397]             if (.Platform$OS.type == "windows") {
[17:29:47.397]                 old_names <- names(...future.oldEnvVars)
[17:29:47.397]                 envs <- base::Sys.getenv()
[17:29:47.397]                 names <- names(envs)
[17:29:47.397]                 common <- intersect(names, old_names)
[17:29:47.397]                 added <- setdiff(names, old_names)
[17:29:47.397]                 removed <- setdiff(old_names, names)
[17:29:47.397]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:47.397]                   envs[common]]
[17:29:47.397]                 NAMES <- toupper(changed)
[17:29:47.397]                 args <- list()
[17:29:47.397]                 for (kk in seq_along(NAMES)) {
[17:29:47.397]                   name <- changed[[kk]]
[17:29:47.397]                   NAME <- NAMES[[kk]]
[17:29:47.397]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.397]                     next
[17:29:47.397]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.397]                 }
[17:29:47.397]                 NAMES <- toupper(added)
[17:29:47.397]                 for (kk in seq_along(NAMES)) {
[17:29:47.397]                   name <- added[[kk]]
[17:29:47.397]                   NAME <- NAMES[[kk]]
[17:29:47.397]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.397]                     next
[17:29:47.397]                   args[[name]] <- ""
[17:29:47.397]                 }
[17:29:47.397]                 NAMES <- toupper(removed)
[17:29:47.397]                 for (kk in seq_along(NAMES)) {
[17:29:47.397]                   name <- removed[[kk]]
[17:29:47.397]                   NAME <- NAMES[[kk]]
[17:29:47.397]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.397]                     next
[17:29:47.397]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.397]                 }
[17:29:47.397]                 if (length(args) > 0) 
[17:29:47.397]                   base::do.call(base::Sys.setenv, args = args)
[17:29:47.397]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:47.397]             }
[17:29:47.397]             else {
[17:29:47.397]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:47.397]             }
[17:29:47.397]             {
[17:29:47.397]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:47.397]                   0L) {
[17:29:47.397]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:47.397]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:47.397]                   base::options(opts)
[17:29:47.397]                 }
[17:29:47.397]                 {
[17:29:47.397]                   {
[17:29:47.397]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:47.397]                     NULL
[17:29:47.397]                   }
[17:29:47.397]                   options(future.plan = NULL)
[17:29:47.397]                   if (is.na(NA_character_)) 
[17:29:47.397]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.397]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:47.397]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:47.397]                     .init = FALSE)
[17:29:47.397]                 }
[17:29:47.397]             }
[17:29:47.397]         }
[17:29:47.397]     })
[17:29:47.397]     if (TRUE) {
[17:29:47.397]         base::sink(type = "output", split = FALSE)
[17:29:47.397]         if (TRUE) {
[17:29:47.397]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:47.397]         }
[17:29:47.397]         else {
[17:29:47.397]             ...future.result["stdout"] <- base::list(NULL)
[17:29:47.397]         }
[17:29:47.397]         base::close(...future.stdout)
[17:29:47.397]         ...future.stdout <- NULL
[17:29:47.397]     }
[17:29:47.397]     ...future.result$conditions <- ...future.conditions
[17:29:47.397]     ...future.result$finished <- base::Sys.time()
[17:29:47.397]     ...future.result
[17:29:47.397] }
[17:29:47.405] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:47.405] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:47.406] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:47.406] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:47.407] MultisessionFuture started
[17:29:47.408] - Launch lazy future ... done
[17:29:47.408] run() for 'MultisessionFuture' ... done
[17:29:47.409] getGlobalsAndPackages() ...
[17:29:47.409] Searching for globals...
[17:29:47.411] - globals found: [3] '{', 'sample', 'x'
[17:29:47.411] Searching for globals ... DONE
[17:29:47.411] Resolving globals: FALSE
[17:29:47.411] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:47.412] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:47.412] - globals: [1] 'x'
[17:29:47.412] 
[17:29:47.412] getGlobalsAndPackages() ... DONE
[17:29:47.413] run() for 'Future' ...
[17:29:47.413] - state: 'created'
[17:29:47.413] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:47.428] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:47.428] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:47.429]   - Field: 'node'
[17:29:47.429]   - Field: 'label'
[17:29:47.429]   - Field: 'local'
[17:29:47.430]   - Field: 'owner'
[17:29:47.430]   - Field: 'envir'
[17:29:47.430]   - Field: 'workers'
[17:29:47.430]   - Field: 'packages'
[17:29:47.431]   - Field: 'gc'
[17:29:47.431]   - Field: 'conditions'
[17:29:47.431]   - Field: 'persistent'
[17:29:47.431]   - Field: 'expr'
[17:29:47.432]   - Field: 'uuid'
[17:29:47.432]   - Field: 'seed'
[17:29:47.432]   - Field: 'version'
[17:29:47.432]   - Field: 'result'
[17:29:47.432]   - Field: 'asynchronous'
[17:29:47.433]   - Field: 'calls'
[17:29:47.433]   - Field: 'globals'
[17:29:47.433]   - Field: 'stdout'
[17:29:47.433]   - Field: 'earlySignal'
[17:29:47.434]   - Field: 'lazy'
[17:29:47.434]   - Field: 'state'
[17:29:47.434] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:47.434] - Launch lazy future ...
[17:29:47.434] Packages needed by the future expression (n = 0): <none>
[17:29:47.435] Packages needed by future strategies (n = 0): <none>
[17:29:47.435] {
[17:29:47.435]     {
[17:29:47.435]         {
[17:29:47.435]             ...future.startTime <- base::Sys.time()
[17:29:47.435]             {
[17:29:47.435]                 {
[17:29:47.435]                   {
[17:29:47.435]                     {
[17:29:47.435]                       base::local({
[17:29:47.435]                         has_future <- base::requireNamespace("future", 
[17:29:47.435]                           quietly = TRUE)
[17:29:47.435]                         if (has_future) {
[17:29:47.435]                           ns <- base::getNamespace("future")
[17:29:47.435]                           version <- ns[[".package"]][["version"]]
[17:29:47.435]                           if (is.null(version)) 
[17:29:47.435]                             version <- utils::packageVersion("future")
[17:29:47.435]                         }
[17:29:47.435]                         else {
[17:29:47.435]                           version <- NULL
[17:29:47.435]                         }
[17:29:47.435]                         if (!has_future || version < "1.8.0") {
[17:29:47.435]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:47.435]                             "", base::R.version$version.string), 
[17:29:47.435]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:47.435]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:47.435]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:47.435]                               "release", "version")], collapse = " "), 
[17:29:47.435]                             hostname = base::Sys.info()[["nodename"]])
[17:29:47.435]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:47.435]                             info)
[17:29:47.435]                           info <- base::paste(info, collapse = "; ")
[17:29:47.435]                           if (!has_future) {
[17:29:47.435]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:47.435]                               info)
[17:29:47.435]                           }
[17:29:47.435]                           else {
[17:29:47.435]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:47.435]                               info, version)
[17:29:47.435]                           }
[17:29:47.435]                           base::stop(msg)
[17:29:47.435]                         }
[17:29:47.435]                       })
[17:29:47.435]                     }
[17:29:47.435]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:47.435]                     base::options(mc.cores = 1L)
[17:29:47.435]                   }
[17:29:47.435]                   ...future.strategy.old <- future::plan("list")
[17:29:47.435]                   options(future.plan = NULL)
[17:29:47.435]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.435]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:47.435]                 }
[17:29:47.435]                 ...future.workdir <- getwd()
[17:29:47.435]             }
[17:29:47.435]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:47.435]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:47.435]         }
[17:29:47.435]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:47.435]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:47.435]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:47.435]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:47.435]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:47.435]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:47.435]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:47.435]             base::names(...future.oldOptions))
[17:29:47.435]     }
[17:29:47.435]     if (FALSE) {
[17:29:47.435]     }
[17:29:47.435]     else {
[17:29:47.435]         if (TRUE) {
[17:29:47.435]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:47.435]                 open = "w")
[17:29:47.435]         }
[17:29:47.435]         else {
[17:29:47.435]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:47.435]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:47.435]         }
[17:29:47.435]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:47.435]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:47.435]             base::sink(type = "output", split = FALSE)
[17:29:47.435]             base::close(...future.stdout)
[17:29:47.435]         }, add = TRUE)
[17:29:47.435]     }
[17:29:47.435]     ...future.frame <- base::sys.nframe()
[17:29:47.435]     ...future.conditions <- base::list()
[17:29:47.435]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:47.435]     if (FALSE) {
[17:29:47.435]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:47.435]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:47.435]     }
[17:29:47.435]     ...future.result <- base::tryCatch({
[17:29:47.435]         base::withCallingHandlers({
[17:29:47.435]             ...future.value <- base::withVisible(base::local({
[17:29:47.435]                 ...future.makeSendCondition <- base::local({
[17:29:47.435]                   sendCondition <- NULL
[17:29:47.435]                   function(frame = 1L) {
[17:29:47.435]                     if (is.function(sendCondition)) 
[17:29:47.435]                       return(sendCondition)
[17:29:47.435]                     ns <- getNamespace("parallel")
[17:29:47.435]                     if (exists("sendData", mode = "function", 
[17:29:47.435]                       envir = ns)) {
[17:29:47.435]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:47.435]                         envir = ns)
[17:29:47.435]                       envir <- sys.frame(frame)
[17:29:47.435]                       master <- NULL
[17:29:47.435]                       while (!identical(envir, .GlobalEnv) && 
[17:29:47.435]                         !identical(envir, emptyenv())) {
[17:29:47.435]                         if (exists("master", mode = "list", envir = envir, 
[17:29:47.435]                           inherits = FALSE)) {
[17:29:47.435]                           master <- get("master", mode = "list", 
[17:29:47.435]                             envir = envir, inherits = FALSE)
[17:29:47.435]                           if (inherits(master, c("SOCKnode", 
[17:29:47.435]                             "SOCK0node"))) {
[17:29:47.435]                             sendCondition <<- function(cond) {
[17:29:47.435]                               data <- list(type = "VALUE", value = cond, 
[17:29:47.435]                                 success = TRUE)
[17:29:47.435]                               parallel_sendData(master, data)
[17:29:47.435]                             }
[17:29:47.435]                             return(sendCondition)
[17:29:47.435]                           }
[17:29:47.435]                         }
[17:29:47.435]                         frame <- frame + 1L
[17:29:47.435]                         envir <- sys.frame(frame)
[17:29:47.435]                       }
[17:29:47.435]                     }
[17:29:47.435]                     sendCondition <<- function(cond) NULL
[17:29:47.435]                   }
[17:29:47.435]                 })
[17:29:47.435]                 withCallingHandlers({
[17:29:47.435]                   {
[17:29:47.435]                     sample(x, size = 1L)
[17:29:47.435]                   }
[17:29:47.435]                 }, immediateCondition = function(cond) {
[17:29:47.435]                   sendCondition <- ...future.makeSendCondition()
[17:29:47.435]                   sendCondition(cond)
[17:29:47.435]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.435]                   {
[17:29:47.435]                     inherits <- base::inherits
[17:29:47.435]                     invokeRestart <- base::invokeRestart
[17:29:47.435]                     is.null <- base::is.null
[17:29:47.435]                     muffled <- FALSE
[17:29:47.435]                     if (inherits(cond, "message")) {
[17:29:47.435]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:47.435]                       if (muffled) 
[17:29:47.435]                         invokeRestart("muffleMessage")
[17:29:47.435]                     }
[17:29:47.435]                     else if (inherits(cond, "warning")) {
[17:29:47.435]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:47.435]                       if (muffled) 
[17:29:47.435]                         invokeRestart("muffleWarning")
[17:29:47.435]                     }
[17:29:47.435]                     else if (inherits(cond, "condition")) {
[17:29:47.435]                       if (!is.null(pattern)) {
[17:29:47.435]                         computeRestarts <- base::computeRestarts
[17:29:47.435]                         grepl <- base::grepl
[17:29:47.435]                         restarts <- computeRestarts(cond)
[17:29:47.435]                         for (restart in restarts) {
[17:29:47.435]                           name <- restart$name
[17:29:47.435]                           if (is.null(name)) 
[17:29:47.435]                             next
[17:29:47.435]                           if (!grepl(pattern, name)) 
[17:29:47.435]                             next
[17:29:47.435]                           invokeRestart(restart)
[17:29:47.435]                           muffled <- TRUE
[17:29:47.435]                           break
[17:29:47.435]                         }
[17:29:47.435]                       }
[17:29:47.435]                     }
[17:29:47.435]                     invisible(muffled)
[17:29:47.435]                   }
[17:29:47.435]                   muffleCondition(cond)
[17:29:47.435]                 })
[17:29:47.435]             }))
[17:29:47.435]             future::FutureResult(value = ...future.value$value, 
[17:29:47.435]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.435]                   ...future.rng), globalenv = if (FALSE) 
[17:29:47.435]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:47.435]                     ...future.globalenv.names))
[17:29:47.435]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:47.435]         }, condition = base::local({
[17:29:47.435]             c <- base::c
[17:29:47.435]             inherits <- base::inherits
[17:29:47.435]             invokeRestart <- base::invokeRestart
[17:29:47.435]             length <- base::length
[17:29:47.435]             list <- base::list
[17:29:47.435]             seq.int <- base::seq.int
[17:29:47.435]             signalCondition <- base::signalCondition
[17:29:47.435]             sys.calls <- base::sys.calls
[17:29:47.435]             `[[` <- base::`[[`
[17:29:47.435]             `+` <- base::`+`
[17:29:47.435]             `<<-` <- base::`<<-`
[17:29:47.435]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:47.435]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:47.435]                   3L)]
[17:29:47.435]             }
[17:29:47.435]             function(cond) {
[17:29:47.435]                 is_error <- inherits(cond, "error")
[17:29:47.435]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:47.435]                   NULL)
[17:29:47.435]                 if (is_error) {
[17:29:47.435]                   sessionInformation <- function() {
[17:29:47.435]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:47.435]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:47.435]                       search = base::search(), system = base::Sys.info())
[17:29:47.435]                   }
[17:29:47.435]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.435]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:47.435]                     cond$call), session = sessionInformation(), 
[17:29:47.435]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:47.435]                   signalCondition(cond)
[17:29:47.435]                 }
[17:29:47.435]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:47.435]                 "immediateCondition"))) {
[17:29:47.435]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:47.435]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.435]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:47.435]                   if (TRUE && !signal) {
[17:29:47.435]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.435]                     {
[17:29:47.435]                       inherits <- base::inherits
[17:29:47.435]                       invokeRestart <- base::invokeRestart
[17:29:47.435]                       is.null <- base::is.null
[17:29:47.435]                       muffled <- FALSE
[17:29:47.435]                       if (inherits(cond, "message")) {
[17:29:47.435]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.435]                         if (muffled) 
[17:29:47.435]                           invokeRestart("muffleMessage")
[17:29:47.435]                       }
[17:29:47.435]                       else if (inherits(cond, "warning")) {
[17:29:47.435]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.435]                         if (muffled) 
[17:29:47.435]                           invokeRestart("muffleWarning")
[17:29:47.435]                       }
[17:29:47.435]                       else if (inherits(cond, "condition")) {
[17:29:47.435]                         if (!is.null(pattern)) {
[17:29:47.435]                           computeRestarts <- base::computeRestarts
[17:29:47.435]                           grepl <- base::grepl
[17:29:47.435]                           restarts <- computeRestarts(cond)
[17:29:47.435]                           for (restart in restarts) {
[17:29:47.435]                             name <- restart$name
[17:29:47.435]                             if (is.null(name)) 
[17:29:47.435]                               next
[17:29:47.435]                             if (!grepl(pattern, name)) 
[17:29:47.435]                               next
[17:29:47.435]                             invokeRestart(restart)
[17:29:47.435]                             muffled <- TRUE
[17:29:47.435]                             break
[17:29:47.435]                           }
[17:29:47.435]                         }
[17:29:47.435]                       }
[17:29:47.435]                       invisible(muffled)
[17:29:47.435]                     }
[17:29:47.435]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.435]                   }
[17:29:47.435]                 }
[17:29:47.435]                 else {
[17:29:47.435]                   if (TRUE) {
[17:29:47.435]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.435]                     {
[17:29:47.435]                       inherits <- base::inherits
[17:29:47.435]                       invokeRestart <- base::invokeRestart
[17:29:47.435]                       is.null <- base::is.null
[17:29:47.435]                       muffled <- FALSE
[17:29:47.435]                       if (inherits(cond, "message")) {
[17:29:47.435]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.435]                         if (muffled) 
[17:29:47.435]                           invokeRestart("muffleMessage")
[17:29:47.435]                       }
[17:29:47.435]                       else if (inherits(cond, "warning")) {
[17:29:47.435]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.435]                         if (muffled) 
[17:29:47.435]                           invokeRestart("muffleWarning")
[17:29:47.435]                       }
[17:29:47.435]                       else if (inherits(cond, "condition")) {
[17:29:47.435]                         if (!is.null(pattern)) {
[17:29:47.435]                           computeRestarts <- base::computeRestarts
[17:29:47.435]                           grepl <- base::grepl
[17:29:47.435]                           restarts <- computeRestarts(cond)
[17:29:47.435]                           for (restart in restarts) {
[17:29:47.435]                             name <- restart$name
[17:29:47.435]                             if (is.null(name)) 
[17:29:47.435]                               next
[17:29:47.435]                             if (!grepl(pattern, name)) 
[17:29:47.435]                               next
[17:29:47.435]                             invokeRestart(restart)
[17:29:47.435]                             muffled <- TRUE
[17:29:47.435]                             break
[17:29:47.435]                           }
[17:29:47.435]                         }
[17:29:47.435]                       }
[17:29:47.435]                       invisible(muffled)
[17:29:47.435]                     }
[17:29:47.435]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.435]                   }
[17:29:47.435]                 }
[17:29:47.435]             }
[17:29:47.435]         }))
[17:29:47.435]     }, error = function(ex) {
[17:29:47.435]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:47.435]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.435]                 ...future.rng), started = ...future.startTime, 
[17:29:47.435]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:47.435]             version = "1.8"), class = "FutureResult")
[17:29:47.435]     }, finally = {
[17:29:47.435]         if (!identical(...future.workdir, getwd())) 
[17:29:47.435]             setwd(...future.workdir)
[17:29:47.435]         {
[17:29:47.435]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:47.435]                 ...future.oldOptions$nwarnings <- NULL
[17:29:47.435]             }
[17:29:47.435]             base::options(...future.oldOptions)
[17:29:47.435]             if (.Platform$OS.type == "windows") {
[17:29:47.435]                 old_names <- names(...future.oldEnvVars)
[17:29:47.435]                 envs <- base::Sys.getenv()
[17:29:47.435]                 names <- names(envs)
[17:29:47.435]                 common <- intersect(names, old_names)
[17:29:47.435]                 added <- setdiff(names, old_names)
[17:29:47.435]                 removed <- setdiff(old_names, names)
[17:29:47.435]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:47.435]                   envs[common]]
[17:29:47.435]                 NAMES <- toupper(changed)
[17:29:47.435]                 args <- list()
[17:29:47.435]                 for (kk in seq_along(NAMES)) {
[17:29:47.435]                   name <- changed[[kk]]
[17:29:47.435]                   NAME <- NAMES[[kk]]
[17:29:47.435]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.435]                     next
[17:29:47.435]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.435]                 }
[17:29:47.435]                 NAMES <- toupper(added)
[17:29:47.435]                 for (kk in seq_along(NAMES)) {
[17:29:47.435]                   name <- added[[kk]]
[17:29:47.435]                   NAME <- NAMES[[kk]]
[17:29:47.435]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.435]                     next
[17:29:47.435]                   args[[name]] <- ""
[17:29:47.435]                 }
[17:29:47.435]                 NAMES <- toupper(removed)
[17:29:47.435]                 for (kk in seq_along(NAMES)) {
[17:29:47.435]                   name <- removed[[kk]]
[17:29:47.435]                   NAME <- NAMES[[kk]]
[17:29:47.435]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.435]                     next
[17:29:47.435]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.435]                 }
[17:29:47.435]                 if (length(args) > 0) 
[17:29:47.435]                   base::do.call(base::Sys.setenv, args = args)
[17:29:47.435]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:47.435]             }
[17:29:47.435]             else {
[17:29:47.435]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:47.435]             }
[17:29:47.435]             {
[17:29:47.435]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:47.435]                   0L) {
[17:29:47.435]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:47.435]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:47.435]                   base::options(opts)
[17:29:47.435]                 }
[17:29:47.435]                 {
[17:29:47.435]                   {
[17:29:47.435]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:47.435]                     NULL
[17:29:47.435]                   }
[17:29:47.435]                   options(future.plan = NULL)
[17:29:47.435]                   if (is.na(NA_character_)) 
[17:29:47.435]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.435]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:47.435]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:47.435]                     .init = FALSE)
[17:29:47.435]                 }
[17:29:47.435]             }
[17:29:47.435]         }
[17:29:47.435]     })
[17:29:47.435]     if (TRUE) {
[17:29:47.435]         base::sink(type = "output", split = FALSE)
[17:29:47.435]         if (TRUE) {
[17:29:47.435]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:47.435]         }
[17:29:47.435]         else {
[17:29:47.435]             ...future.result["stdout"] <- base::list(NULL)
[17:29:47.435]         }
[17:29:47.435]         base::close(...future.stdout)
[17:29:47.435]         ...future.stdout <- NULL
[17:29:47.435]     }
[17:29:47.435]     ...future.result$conditions <- ...future.conditions
[17:29:47.435]     ...future.result$finished <- base::Sys.time()
[17:29:47.435]     ...future.result
[17:29:47.435] }
[17:29:47.440] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:47.457] receiveMessageFromWorker() for ClusterFuture ...
[17:29:47.458] - Validating connection of MultisessionFuture
[17:29:47.458] - received message: FutureResult
[17:29:47.458] - Received FutureResult
[17:29:47.459] - Erased future from FutureRegistry
[17:29:47.459] result() for ClusterFuture ...
[17:29:47.459] - result already collected: FutureResult
[17:29:47.459] result() for ClusterFuture ... done
[17:29:47.460] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:47.460] result() for ClusterFuture ...
[17:29:47.460] - result already collected: FutureResult
[17:29:47.460] result() for ClusterFuture ... done
[17:29:47.461] result() for ClusterFuture ...
[17:29:47.461] - result already collected: FutureResult
[17:29:47.461] result() for ClusterFuture ... done
[17:29:47.462] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:47.463] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:47.464] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:47.465] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:47.466] MultisessionFuture started
[17:29:47.467] - Launch lazy future ... done
[17:29:47.467] run() for 'MultisessionFuture' ... done
[17:29:47.469] getGlobalsAndPackages() ...
[17:29:47.469] Searching for globals...
[17:29:47.472] - globals found: [3] '{', 'sample', 'x'
[17:29:47.472] Searching for globals ... DONE
[17:29:47.472] Resolving globals: FALSE
[17:29:47.474] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:47.474] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:47.475] - globals: [1] 'x'
[17:29:47.475] 
[17:29:47.476] getGlobalsAndPackages() ... DONE
[17:29:47.476] run() for 'Future' ...
[17:29:47.477] - state: 'created'
[17:29:47.477] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:47.499] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:47.500] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:47.500]   - Field: 'node'
[17:29:47.501]   - Field: 'label'
[17:29:47.501]   - Field: 'local'
[17:29:47.501]   - Field: 'owner'
[17:29:47.502]   - Field: 'envir'
[17:29:47.502]   - Field: 'workers'
[17:29:47.502]   - Field: 'packages'
[17:29:47.503]   - Field: 'gc'
[17:29:47.503]   - Field: 'conditions'
[17:29:47.503]   - Field: 'persistent'
[17:29:47.504]   - Field: 'expr'
[17:29:47.504]   - Field: 'uuid'
[17:29:47.505]   - Field: 'seed'
[17:29:47.505]   - Field: 'version'
[17:29:47.505]   - Field: 'result'
[17:29:47.506]   - Field: 'asynchronous'
[17:29:47.506]   - Field: 'calls'
[17:29:47.506]   - Field: 'globals'
[17:29:47.507]   - Field: 'stdout'
[17:29:47.507]   - Field: 'earlySignal'
[17:29:47.507]   - Field: 'lazy'
[17:29:47.508]   - Field: 'state'
[17:29:47.508] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:47.508] - Launch lazy future ...
[17:29:47.509] Packages needed by the future expression (n = 0): <none>
[17:29:47.510] Packages needed by future strategies (n = 0): <none>
[17:29:47.511] {
[17:29:47.511]     {
[17:29:47.511]         {
[17:29:47.511]             ...future.startTime <- base::Sys.time()
[17:29:47.511]             {
[17:29:47.511]                 {
[17:29:47.511]                   {
[17:29:47.511]                     {
[17:29:47.511]                       base::local({
[17:29:47.511]                         has_future <- base::requireNamespace("future", 
[17:29:47.511]                           quietly = TRUE)
[17:29:47.511]                         if (has_future) {
[17:29:47.511]                           ns <- base::getNamespace("future")
[17:29:47.511]                           version <- ns[[".package"]][["version"]]
[17:29:47.511]                           if (is.null(version)) 
[17:29:47.511]                             version <- utils::packageVersion("future")
[17:29:47.511]                         }
[17:29:47.511]                         else {
[17:29:47.511]                           version <- NULL
[17:29:47.511]                         }
[17:29:47.511]                         if (!has_future || version < "1.8.0") {
[17:29:47.511]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:47.511]                             "", base::R.version$version.string), 
[17:29:47.511]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:47.511]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:47.511]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:47.511]                               "release", "version")], collapse = " "), 
[17:29:47.511]                             hostname = base::Sys.info()[["nodename"]])
[17:29:47.511]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:47.511]                             info)
[17:29:47.511]                           info <- base::paste(info, collapse = "; ")
[17:29:47.511]                           if (!has_future) {
[17:29:47.511]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:47.511]                               info)
[17:29:47.511]                           }
[17:29:47.511]                           else {
[17:29:47.511]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:47.511]                               info, version)
[17:29:47.511]                           }
[17:29:47.511]                           base::stop(msg)
[17:29:47.511]                         }
[17:29:47.511]                       })
[17:29:47.511]                     }
[17:29:47.511]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:47.511]                     base::options(mc.cores = 1L)
[17:29:47.511]                   }
[17:29:47.511]                   ...future.strategy.old <- future::plan("list")
[17:29:47.511]                   options(future.plan = NULL)
[17:29:47.511]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.511]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:47.511]                 }
[17:29:47.511]                 ...future.workdir <- getwd()
[17:29:47.511]             }
[17:29:47.511]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:47.511]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:47.511]         }
[17:29:47.511]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:47.511]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:47.511]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:47.511]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:47.511]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:47.511]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:47.511]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:47.511]             base::names(...future.oldOptions))
[17:29:47.511]     }
[17:29:47.511]     if (FALSE) {
[17:29:47.511]     }
[17:29:47.511]     else {
[17:29:47.511]         if (TRUE) {
[17:29:47.511]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:47.511]                 open = "w")
[17:29:47.511]         }
[17:29:47.511]         else {
[17:29:47.511]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:47.511]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:47.511]         }
[17:29:47.511]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:47.511]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:47.511]             base::sink(type = "output", split = FALSE)
[17:29:47.511]             base::close(...future.stdout)
[17:29:47.511]         }, add = TRUE)
[17:29:47.511]     }
[17:29:47.511]     ...future.frame <- base::sys.nframe()
[17:29:47.511]     ...future.conditions <- base::list()
[17:29:47.511]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:47.511]     if (FALSE) {
[17:29:47.511]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:47.511]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:47.511]     }
[17:29:47.511]     ...future.result <- base::tryCatch({
[17:29:47.511]         base::withCallingHandlers({
[17:29:47.511]             ...future.value <- base::withVisible(base::local({
[17:29:47.511]                 ...future.makeSendCondition <- base::local({
[17:29:47.511]                   sendCondition <- NULL
[17:29:47.511]                   function(frame = 1L) {
[17:29:47.511]                     if (is.function(sendCondition)) 
[17:29:47.511]                       return(sendCondition)
[17:29:47.511]                     ns <- getNamespace("parallel")
[17:29:47.511]                     if (exists("sendData", mode = "function", 
[17:29:47.511]                       envir = ns)) {
[17:29:47.511]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:47.511]                         envir = ns)
[17:29:47.511]                       envir <- sys.frame(frame)
[17:29:47.511]                       master <- NULL
[17:29:47.511]                       while (!identical(envir, .GlobalEnv) && 
[17:29:47.511]                         !identical(envir, emptyenv())) {
[17:29:47.511]                         if (exists("master", mode = "list", envir = envir, 
[17:29:47.511]                           inherits = FALSE)) {
[17:29:47.511]                           master <- get("master", mode = "list", 
[17:29:47.511]                             envir = envir, inherits = FALSE)
[17:29:47.511]                           if (inherits(master, c("SOCKnode", 
[17:29:47.511]                             "SOCK0node"))) {
[17:29:47.511]                             sendCondition <<- function(cond) {
[17:29:47.511]                               data <- list(type = "VALUE", value = cond, 
[17:29:47.511]                                 success = TRUE)
[17:29:47.511]                               parallel_sendData(master, data)
[17:29:47.511]                             }
[17:29:47.511]                             return(sendCondition)
[17:29:47.511]                           }
[17:29:47.511]                         }
[17:29:47.511]                         frame <- frame + 1L
[17:29:47.511]                         envir <- sys.frame(frame)
[17:29:47.511]                       }
[17:29:47.511]                     }
[17:29:47.511]                     sendCondition <<- function(cond) NULL
[17:29:47.511]                   }
[17:29:47.511]                 })
[17:29:47.511]                 withCallingHandlers({
[17:29:47.511]                   {
[17:29:47.511]                     sample(x, size = 1L)
[17:29:47.511]                   }
[17:29:47.511]                 }, immediateCondition = function(cond) {
[17:29:47.511]                   sendCondition <- ...future.makeSendCondition()
[17:29:47.511]                   sendCondition(cond)
[17:29:47.511]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.511]                   {
[17:29:47.511]                     inherits <- base::inherits
[17:29:47.511]                     invokeRestart <- base::invokeRestart
[17:29:47.511]                     is.null <- base::is.null
[17:29:47.511]                     muffled <- FALSE
[17:29:47.511]                     if (inherits(cond, "message")) {
[17:29:47.511]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:47.511]                       if (muffled) 
[17:29:47.511]                         invokeRestart("muffleMessage")
[17:29:47.511]                     }
[17:29:47.511]                     else if (inherits(cond, "warning")) {
[17:29:47.511]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:47.511]                       if (muffled) 
[17:29:47.511]                         invokeRestart("muffleWarning")
[17:29:47.511]                     }
[17:29:47.511]                     else if (inherits(cond, "condition")) {
[17:29:47.511]                       if (!is.null(pattern)) {
[17:29:47.511]                         computeRestarts <- base::computeRestarts
[17:29:47.511]                         grepl <- base::grepl
[17:29:47.511]                         restarts <- computeRestarts(cond)
[17:29:47.511]                         for (restart in restarts) {
[17:29:47.511]                           name <- restart$name
[17:29:47.511]                           if (is.null(name)) 
[17:29:47.511]                             next
[17:29:47.511]                           if (!grepl(pattern, name)) 
[17:29:47.511]                             next
[17:29:47.511]                           invokeRestart(restart)
[17:29:47.511]                           muffled <- TRUE
[17:29:47.511]                           break
[17:29:47.511]                         }
[17:29:47.511]                       }
[17:29:47.511]                     }
[17:29:47.511]                     invisible(muffled)
[17:29:47.511]                   }
[17:29:47.511]                   muffleCondition(cond)
[17:29:47.511]                 })
[17:29:47.511]             }))
[17:29:47.511]             future::FutureResult(value = ...future.value$value, 
[17:29:47.511]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.511]                   ...future.rng), globalenv = if (FALSE) 
[17:29:47.511]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:47.511]                     ...future.globalenv.names))
[17:29:47.511]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:47.511]         }, condition = base::local({
[17:29:47.511]             c <- base::c
[17:29:47.511]             inherits <- base::inherits
[17:29:47.511]             invokeRestart <- base::invokeRestart
[17:29:47.511]             length <- base::length
[17:29:47.511]             list <- base::list
[17:29:47.511]             seq.int <- base::seq.int
[17:29:47.511]             signalCondition <- base::signalCondition
[17:29:47.511]             sys.calls <- base::sys.calls
[17:29:47.511]             `[[` <- base::`[[`
[17:29:47.511]             `+` <- base::`+`
[17:29:47.511]             `<<-` <- base::`<<-`
[17:29:47.511]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:47.511]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:47.511]                   3L)]
[17:29:47.511]             }
[17:29:47.511]             function(cond) {
[17:29:47.511]                 is_error <- inherits(cond, "error")
[17:29:47.511]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:47.511]                   NULL)
[17:29:47.511]                 if (is_error) {
[17:29:47.511]                   sessionInformation <- function() {
[17:29:47.511]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:47.511]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:47.511]                       search = base::search(), system = base::Sys.info())
[17:29:47.511]                   }
[17:29:47.511]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.511]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:47.511]                     cond$call), session = sessionInformation(), 
[17:29:47.511]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:47.511]                   signalCondition(cond)
[17:29:47.511]                 }
[17:29:47.511]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:47.511]                 "immediateCondition"))) {
[17:29:47.511]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:47.511]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.511]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:47.511]                   if (TRUE && !signal) {
[17:29:47.511]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.511]                     {
[17:29:47.511]                       inherits <- base::inherits
[17:29:47.511]                       invokeRestart <- base::invokeRestart
[17:29:47.511]                       is.null <- base::is.null
[17:29:47.511]                       muffled <- FALSE
[17:29:47.511]                       if (inherits(cond, "message")) {
[17:29:47.511]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.511]                         if (muffled) 
[17:29:47.511]                           invokeRestart("muffleMessage")
[17:29:47.511]                       }
[17:29:47.511]                       else if (inherits(cond, "warning")) {
[17:29:47.511]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.511]                         if (muffled) 
[17:29:47.511]                           invokeRestart("muffleWarning")
[17:29:47.511]                       }
[17:29:47.511]                       else if (inherits(cond, "condition")) {
[17:29:47.511]                         if (!is.null(pattern)) {
[17:29:47.511]                           computeRestarts <- base::computeRestarts
[17:29:47.511]                           grepl <- base::grepl
[17:29:47.511]                           restarts <- computeRestarts(cond)
[17:29:47.511]                           for (restart in restarts) {
[17:29:47.511]                             name <- restart$name
[17:29:47.511]                             if (is.null(name)) 
[17:29:47.511]                               next
[17:29:47.511]                             if (!grepl(pattern, name)) 
[17:29:47.511]                               next
[17:29:47.511]                             invokeRestart(restart)
[17:29:47.511]                             muffled <- TRUE
[17:29:47.511]                             break
[17:29:47.511]                           }
[17:29:47.511]                         }
[17:29:47.511]                       }
[17:29:47.511]                       invisible(muffled)
[17:29:47.511]                     }
[17:29:47.511]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.511]                   }
[17:29:47.511]                 }
[17:29:47.511]                 else {
[17:29:47.511]                   if (TRUE) {
[17:29:47.511]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.511]                     {
[17:29:47.511]                       inherits <- base::inherits
[17:29:47.511]                       invokeRestart <- base::invokeRestart
[17:29:47.511]                       is.null <- base::is.null
[17:29:47.511]                       muffled <- FALSE
[17:29:47.511]                       if (inherits(cond, "message")) {
[17:29:47.511]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.511]                         if (muffled) 
[17:29:47.511]                           invokeRestart("muffleMessage")
[17:29:47.511]                       }
[17:29:47.511]                       else if (inherits(cond, "warning")) {
[17:29:47.511]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.511]                         if (muffled) 
[17:29:47.511]                           invokeRestart("muffleWarning")
[17:29:47.511]                       }
[17:29:47.511]                       else if (inherits(cond, "condition")) {
[17:29:47.511]                         if (!is.null(pattern)) {
[17:29:47.511]                           computeRestarts <- base::computeRestarts
[17:29:47.511]                           grepl <- base::grepl
[17:29:47.511]                           restarts <- computeRestarts(cond)
[17:29:47.511]                           for (restart in restarts) {
[17:29:47.511]                             name <- restart$name
[17:29:47.511]                             if (is.null(name)) 
[17:29:47.511]                               next
[17:29:47.511]                             if (!grepl(pattern, name)) 
[17:29:47.511]                               next
[17:29:47.511]                             invokeRestart(restart)
[17:29:47.511]                             muffled <- TRUE
[17:29:47.511]                             break
[17:29:47.511]                           }
[17:29:47.511]                         }
[17:29:47.511]                       }
[17:29:47.511]                       invisible(muffled)
[17:29:47.511]                     }
[17:29:47.511]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.511]                   }
[17:29:47.511]                 }
[17:29:47.511]             }
[17:29:47.511]         }))
[17:29:47.511]     }, error = function(ex) {
[17:29:47.511]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:47.511]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.511]                 ...future.rng), started = ...future.startTime, 
[17:29:47.511]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:47.511]             version = "1.8"), class = "FutureResult")
[17:29:47.511]     }, finally = {
[17:29:47.511]         if (!identical(...future.workdir, getwd())) 
[17:29:47.511]             setwd(...future.workdir)
[17:29:47.511]         {
[17:29:47.511]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:47.511]                 ...future.oldOptions$nwarnings <- NULL
[17:29:47.511]             }
[17:29:47.511]             base::options(...future.oldOptions)
[17:29:47.511]             if (.Platform$OS.type == "windows") {
[17:29:47.511]                 old_names <- names(...future.oldEnvVars)
[17:29:47.511]                 envs <- base::Sys.getenv()
[17:29:47.511]                 names <- names(envs)
[17:29:47.511]                 common <- intersect(names, old_names)
[17:29:47.511]                 added <- setdiff(names, old_names)
[17:29:47.511]                 removed <- setdiff(old_names, names)
[17:29:47.511]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:47.511]                   envs[common]]
[17:29:47.511]                 NAMES <- toupper(changed)
[17:29:47.511]                 args <- list()
[17:29:47.511]                 for (kk in seq_along(NAMES)) {
[17:29:47.511]                   name <- changed[[kk]]
[17:29:47.511]                   NAME <- NAMES[[kk]]
[17:29:47.511]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.511]                     next
[17:29:47.511]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.511]                 }
[17:29:47.511]                 NAMES <- toupper(added)
[17:29:47.511]                 for (kk in seq_along(NAMES)) {
[17:29:47.511]                   name <- added[[kk]]
[17:29:47.511]                   NAME <- NAMES[[kk]]
[17:29:47.511]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.511]                     next
[17:29:47.511]                   args[[name]] <- ""
[17:29:47.511]                 }
[17:29:47.511]                 NAMES <- toupper(removed)
[17:29:47.511]                 for (kk in seq_along(NAMES)) {
[17:29:47.511]                   name <- removed[[kk]]
[17:29:47.511]                   NAME <- NAMES[[kk]]
[17:29:47.511]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.511]                     next
[17:29:47.511]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.511]                 }
[17:29:47.511]                 if (length(args) > 0) 
[17:29:47.511]                   base::do.call(base::Sys.setenv, args = args)
[17:29:47.511]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:47.511]             }
[17:29:47.511]             else {
[17:29:47.511]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:47.511]             }
[17:29:47.511]             {
[17:29:47.511]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:47.511]                   0L) {
[17:29:47.511]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:47.511]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:47.511]                   base::options(opts)
[17:29:47.511]                 }
[17:29:47.511]                 {
[17:29:47.511]                   {
[17:29:47.511]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:47.511]                     NULL
[17:29:47.511]                   }
[17:29:47.511]                   options(future.plan = NULL)
[17:29:47.511]                   if (is.na(NA_character_)) 
[17:29:47.511]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.511]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:47.511]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:47.511]                     .init = FALSE)
[17:29:47.511]                 }
[17:29:47.511]             }
[17:29:47.511]         }
[17:29:47.511]     })
[17:29:47.511]     if (TRUE) {
[17:29:47.511]         base::sink(type = "output", split = FALSE)
[17:29:47.511]         if (TRUE) {
[17:29:47.511]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:47.511]         }
[17:29:47.511]         else {
[17:29:47.511]             ...future.result["stdout"] <- base::list(NULL)
[17:29:47.511]         }
[17:29:47.511]         base::close(...future.stdout)
[17:29:47.511]         ...future.stdout <- NULL
[17:29:47.511]     }
[17:29:47.511]     ...future.result$conditions <- ...future.conditions
[17:29:47.511]     ...future.result$finished <- base::Sys.time()
[17:29:47.511]     ...future.result
[17:29:47.511] }
[17:29:47.520] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:47.535] receiveMessageFromWorker() for ClusterFuture ...
[17:29:47.535] - Validating connection of MultisessionFuture
[17:29:47.536] - received message: FutureResult
[17:29:47.536] - Received FutureResult
[17:29:47.536] - Erased future from FutureRegistry
[17:29:47.537] result() for ClusterFuture ...
[17:29:47.537] - result already collected: FutureResult
[17:29:47.537] result() for ClusterFuture ... done
[17:29:47.537] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:47.537] result() for ClusterFuture ...
[17:29:47.537] - result already collected: FutureResult
[17:29:47.538] result() for ClusterFuture ... done
[17:29:47.538] result() for ClusterFuture ...
[17:29:47.538] - result already collected: FutureResult
[17:29:47.538] result() for ClusterFuture ... done
[17:29:47.539] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:47.540] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:47.540] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:47.540] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:47.541] MultisessionFuture started
[17:29:47.541] - Launch lazy future ... done
[17:29:47.542] run() for 'MultisessionFuture' ... done
[17:29:47.542] result() for ClusterFuture ...
[17:29:47.542] - result already collected: FutureResult
[17:29:47.542] result() for ClusterFuture ... done
[17:29:47.542] result() for ClusterFuture ...
[17:29:47.543] - result already collected: FutureResult
[17:29:47.543] result() for ClusterFuture ... done
[17:29:47.543] result() for ClusterFuture ...
[17:29:47.543] - result already collected: FutureResult
[17:29:47.543] result() for ClusterFuture ... done
[17:29:47.544] result() for ClusterFuture ...
[17:29:47.544] - result already collected: FutureResult
[17:29:47.544] result() for ClusterFuture ... done
[17:29:47.544] result() for ClusterFuture ...
[17:29:47.544] receiveMessageFromWorker() for ClusterFuture ...
[17:29:47.544] - Validating connection of MultisessionFuture
[17:29:47.545] - received message: FutureResult
[17:29:47.545] - Received FutureResult
[17:29:47.545] - Erased future from FutureRegistry
[17:29:47.545] result() for ClusterFuture ...
[17:29:47.545] - result already collected: FutureResult
[17:29:47.546] result() for ClusterFuture ... done
[17:29:47.546] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:47.546] result() for ClusterFuture ... done
[17:29:47.546] result() for ClusterFuture ...
[17:29:47.546] - result already collected: FutureResult
[17:29:47.546] result() for ClusterFuture ... done
[17:29:47.547] result() for ClusterFuture ...
[17:29:47.547] receiveMessageFromWorker() for ClusterFuture ...
[17:29:47.547] - Validating connection of MultisessionFuture
[17:29:47.568] - received message: FutureResult
[17:29:47.569] - Received FutureResult
[17:29:47.569] - Erased future from FutureRegistry
[17:29:47.569] result() for ClusterFuture ...
[17:29:47.569] - result already collected: FutureResult
[17:29:47.570] result() for ClusterFuture ... done
[17:29:47.570] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:47.570] result() for ClusterFuture ... done
[17:29:47.570] result() for ClusterFuture ...
[17:29:47.570] - result already collected: FutureResult
[17:29:47.570] result() for ClusterFuture ... done
[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 1

[[4]]
[1] 2

[17:29:47.571] getGlobalsAndPackages() ...
[17:29:47.572] Searching for globals...
[17:29:47.573] - globals found: [3] '{', 'sample', 'x'
[17:29:47.573] Searching for globals ... DONE
[17:29:47.573] Resolving globals: FALSE
[17:29:47.574] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:47.574] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:47.575] - globals: [1] 'x'
[17:29:47.575] 
[17:29:47.575] getGlobalsAndPackages() ... DONE
[17:29:47.575] run() for 'Future' ...
[17:29:47.575] - state: 'created'
[17:29:47.576] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:47.594] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:47.594] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:47.594]   - Field: 'node'
[17:29:47.594]   - Field: 'label'
[17:29:47.594]   - Field: 'local'
[17:29:47.595]   - Field: 'owner'
[17:29:47.595]   - Field: 'envir'
[17:29:47.595]   - Field: 'workers'
[17:29:47.595]   - Field: 'packages'
[17:29:47.595]   - Field: 'gc'
[17:29:47.595]   - Field: 'conditions'
[17:29:47.596]   - Field: 'persistent'
[17:29:47.596]   - Field: 'expr'
[17:29:47.596]   - Field: 'uuid'
[17:29:47.596]   - Field: 'seed'
[17:29:47.596]   - Field: 'version'
[17:29:47.596]   - Field: 'result'
[17:29:47.597]   - Field: 'asynchronous'
[17:29:47.597]   - Field: 'calls'
[17:29:47.597]   - Field: 'globals'
[17:29:47.598]   - Field: 'stdout'
[17:29:47.598]   - Field: 'earlySignal'
[17:29:47.598]   - Field: 'lazy'
[17:29:47.599]   - Field: 'state'
[17:29:47.599] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:47.599] - Launch lazy future ...
[17:29:47.600] Packages needed by the future expression (n = 0): <none>
[17:29:47.601] Packages needed by future strategies (n = 0): <none>
[17:29:47.602] {
[17:29:47.602]     {
[17:29:47.602]         {
[17:29:47.602]             ...future.startTime <- base::Sys.time()
[17:29:47.602]             {
[17:29:47.602]                 {
[17:29:47.602]                   {
[17:29:47.602]                     {
[17:29:47.602]                       base::local({
[17:29:47.602]                         has_future <- base::requireNamespace("future", 
[17:29:47.602]                           quietly = TRUE)
[17:29:47.602]                         if (has_future) {
[17:29:47.602]                           ns <- base::getNamespace("future")
[17:29:47.602]                           version <- ns[[".package"]][["version"]]
[17:29:47.602]                           if (is.null(version)) 
[17:29:47.602]                             version <- utils::packageVersion("future")
[17:29:47.602]                         }
[17:29:47.602]                         else {
[17:29:47.602]                           version <- NULL
[17:29:47.602]                         }
[17:29:47.602]                         if (!has_future || version < "1.8.0") {
[17:29:47.602]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:47.602]                             "", base::R.version$version.string), 
[17:29:47.602]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:47.602]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:47.602]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:47.602]                               "release", "version")], collapse = " "), 
[17:29:47.602]                             hostname = base::Sys.info()[["nodename"]])
[17:29:47.602]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:47.602]                             info)
[17:29:47.602]                           info <- base::paste(info, collapse = "; ")
[17:29:47.602]                           if (!has_future) {
[17:29:47.602]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:47.602]                               info)
[17:29:47.602]                           }
[17:29:47.602]                           else {
[17:29:47.602]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:47.602]                               info, version)
[17:29:47.602]                           }
[17:29:47.602]                           base::stop(msg)
[17:29:47.602]                         }
[17:29:47.602]                       })
[17:29:47.602]                     }
[17:29:47.602]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:47.602]                     base::options(mc.cores = 1L)
[17:29:47.602]                   }
[17:29:47.602]                   ...future.strategy.old <- future::plan("list")
[17:29:47.602]                   options(future.plan = NULL)
[17:29:47.602]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.602]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:47.602]                 }
[17:29:47.602]                 ...future.workdir <- getwd()
[17:29:47.602]             }
[17:29:47.602]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:47.602]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:47.602]         }
[17:29:47.602]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:47.602]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:47.602]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:47.602]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:47.602]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:47.602]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:47.602]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:47.602]             base::names(...future.oldOptions))
[17:29:47.602]     }
[17:29:47.602]     if (FALSE) {
[17:29:47.602]     }
[17:29:47.602]     else {
[17:29:47.602]         if (TRUE) {
[17:29:47.602]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:47.602]                 open = "w")
[17:29:47.602]         }
[17:29:47.602]         else {
[17:29:47.602]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:47.602]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:47.602]         }
[17:29:47.602]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:47.602]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:47.602]             base::sink(type = "output", split = FALSE)
[17:29:47.602]             base::close(...future.stdout)
[17:29:47.602]         }, add = TRUE)
[17:29:47.602]     }
[17:29:47.602]     ...future.frame <- base::sys.nframe()
[17:29:47.602]     ...future.conditions <- base::list()
[17:29:47.602]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:47.602]     if (FALSE) {
[17:29:47.602]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:47.602]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:47.602]     }
[17:29:47.602]     ...future.result <- base::tryCatch({
[17:29:47.602]         base::withCallingHandlers({
[17:29:47.602]             ...future.value <- base::withVisible(base::local({
[17:29:47.602]                 ...future.makeSendCondition <- base::local({
[17:29:47.602]                   sendCondition <- NULL
[17:29:47.602]                   function(frame = 1L) {
[17:29:47.602]                     if (is.function(sendCondition)) 
[17:29:47.602]                       return(sendCondition)
[17:29:47.602]                     ns <- getNamespace("parallel")
[17:29:47.602]                     if (exists("sendData", mode = "function", 
[17:29:47.602]                       envir = ns)) {
[17:29:47.602]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:47.602]                         envir = ns)
[17:29:47.602]                       envir <- sys.frame(frame)
[17:29:47.602]                       master <- NULL
[17:29:47.602]                       while (!identical(envir, .GlobalEnv) && 
[17:29:47.602]                         !identical(envir, emptyenv())) {
[17:29:47.602]                         if (exists("master", mode = "list", envir = envir, 
[17:29:47.602]                           inherits = FALSE)) {
[17:29:47.602]                           master <- get("master", mode = "list", 
[17:29:47.602]                             envir = envir, inherits = FALSE)
[17:29:47.602]                           if (inherits(master, c("SOCKnode", 
[17:29:47.602]                             "SOCK0node"))) {
[17:29:47.602]                             sendCondition <<- function(cond) {
[17:29:47.602]                               data <- list(type = "VALUE", value = cond, 
[17:29:47.602]                                 success = TRUE)
[17:29:47.602]                               parallel_sendData(master, data)
[17:29:47.602]                             }
[17:29:47.602]                             return(sendCondition)
[17:29:47.602]                           }
[17:29:47.602]                         }
[17:29:47.602]                         frame <- frame + 1L
[17:29:47.602]                         envir <- sys.frame(frame)
[17:29:47.602]                       }
[17:29:47.602]                     }
[17:29:47.602]                     sendCondition <<- function(cond) NULL
[17:29:47.602]                   }
[17:29:47.602]                 })
[17:29:47.602]                 withCallingHandlers({
[17:29:47.602]                   {
[17:29:47.602]                     sample(x, size = 1L)
[17:29:47.602]                   }
[17:29:47.602]                 }, immediateCondition = function(cond) {
[17:29:47.602]                   sendCondition <- ...future.makeSendCondition()
[17:29:47.602]                   sendCondition(cond)
[17:29:47.602]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.602]                   {
[17:29:47.602]                     inherits <- base::inherits
[17:29:47.602]                     invokeRestart <- base::invokeRestart
[17:29:47.602]                     is.null <- base::is.null
[17:29:47.602]                     muffled <- FALSE
[17:29:47.602]                     if (inherits(cond, "message")) {
[17:29:47.602]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:47.602]                       if (muffled) 
[17:29:47.602]                         invokeRestart("muffleMessage")
[17:29:47.602]                     }
[17:29:47.602]                     else if (inherits(cond, "warning")) {
[17:29:47.602]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:47.602]                       if (muffled) 
[17:29:47.602]                         invokeRestart("muffleWarning")
[17:29:47.602]                     }
[17:29:47.602]                     else if (inherits(cond, "condition")) {
[17:29:47.602]                       if (!is.null(pattern)) {
[17:29:47.602]                         computeRestarts <- base::computeRestarts
[17:29:47.602]                         grepl <- base::grepl
[17:29:47.602]                         restarts <- computeRestarts(cond)
[17:29:47.602]                         for (restart in restarts) {
[17:29:47.602]                           name <- restart$name
[17:29:47.602]                           if (is.null(name)) 
[17:29:47.602]                             next
[17:29:47.602]                           if (!grepl(pattern, name)) 
[17:29:47.602]                             next
[17:29:47.602]                           invokeRestart(restart)
[17:29:47.602]                           muffled <- TRUE
[17:29:47.602]                           break
[17:29:47.602]                         }
[17:29:47.602]                       }
[17:29:47.602]                     }
[17:29:47.602]                     invisible(muffled)
[17:29:47.602]                   }
[17:29:47.602]                   muffleCondition(cond)
[17:29:47.602]                 })
[17:29:47.602]             }))
[17:29:47.602]             future::FutureResult(value = ...future.value$value, 
[17:29:47.602]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.602]                   ...future.rng), globalenv = if (FALSE) 
[17:29:47.602]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:47.602]                     ...future.globalenv.names))
[17:29:47.602]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:47.602]         }, condition = base::local({
[17:29:47.602]             c <- base::c
[17:29:47.602]             inherits <- base::inherits
[17:29:47.602]             invokeRestart <- base::invokeRestart
[17:29:47.602]             length <- base::length
[17:29:47.602]             list <- base::list
[17:29:47.602]             seq.int <- base::seq.int
[17:29:47.602]             signalCondition <- base::signalCondition
[17:29:47.602]             sys.calls <- base::sys.calls
[17:29:47.602]             `[[` <- base::`[[`
[17:29:47.602]             `+` <- base::`+`
[17:29:47.602]             `<<-` <- base::`<<-`
[17:29:47.602]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:47.602]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:47.602]                   3L)]
[17:29:47.602]             }
[17:29:47.602]             function(cond) {
[17:29:47.602]                 is_error <- inherits(cond, "error")
[17:29:47.602]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:47.602]                   NULL)
[17:29:47.602]                 if (is_error) {
[17:29:47.602]                   sessionInformation <- function() {
[17:29:47.602]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:47.602]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:47.602]                       search = base::search(), system = base::Sys.info())
[17:29:47.602]                   }
[17:29:47.602]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.602]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:47.602]                     cond$call), session = sessionInformation(), 
[17:29:47.602]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:47.602]                   signalCondition(cond)
[17:29:47.602]                 }
[17:29:47.602]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:47.602]                 "immediateCondition"))) {
[17:29:47.602]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:47.602]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.602]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:47.602]                   if (TRUE && !signal) {
[17:29:47.602]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.602]                     {
[17:29:47.602]                       inherits <- base::inherits
[17:29:47.602]                       invokeRestart <- base::invokeRestart
[17:29:47.602]                       is.null <- base::is.null
[17:29:47.602]                       muffled <- FALSE
[17:29:47.602]                       if (inherits(cond, "message")) {
[17:29:47.602]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.602]                         if (muffled) 
[17:29:47.602]                           invokeRestart("muffleMessage")
[17:29:47.602]                       }
[17:29:47.602]                       else if (inherits(cond, "warning")) {
[17:29:47.602]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.602]                         if (muffled) 
[17:29:47.602]                           invokeRestart("muffleWarning")
[17:29:47.602]                       }
[17:29:47.602]                       else if (inherits(cond, "condition")) {
[17:29:47.602]                         if (!is.null(pattern)) {
[17:29:47.602]                           computeRestarts <- base::computeRestarts
[17:29:47.602]                           grepl <- base::grepl
[17:29:47.602]                           restarts <- computeRestarts(cond)
[17:29:47.602]                           for (restart in restarts) {
[17:29:47.602]                             name <- restart$name
[17:29:47.602]                             if (is.null(name)) 
[17:29:47.602]                               next
[17:29:47.602]                             if (!grepl(pattern, name)) 
[17:29:47.602]                               next
[17:29:47.602]                             invokeRestart(restart)
[17:29:47.602]                             muffled <- TRUE
[17:29:47.602]                             break
[17:29:47.602]                           }
[17:29:47.602]                         }
[17:29:47.602]                       }
[17:29:47.602]                       invisible(muffled)
[17:29:47.602]                     }
[17:29:47.602]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.602]                   }
[17:29:47.602]                 }
[17:29:47.602]                 else {
[17:29:47.602]                   if (TRUE) {
[17:29:47.602]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.602]                     {
[17:29:47.602]                       inherits <- base::inherits
[17:29:47.602]                       invokeRestart <- base::invokeRestart
[17:29:47.602]                       is.null <- base::is.null
[17:29:47.602]                       muffled <- FALSE
[17:29:47.602]                       if (inherits(cond, "message")) {
[17:29:47.602]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.602]                         if (muffled) 
[17:29:47.602]                           invokeRestart("muffleMessage")
[17:29:47.602]                       }
[17:29:47.602]                       else if (inherits(cond, "warning")) {
[17:29:47.602]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.602]                         if (muffled) 
[17:29:47.602]                           invokeRestart("muffleWarning")
[17:29:47.602]                       }
[17:29:47.602]                       else if (inherits(cond, "condition")) {
[17:29:47.602]                         if (!is.null(pattern)) {
[17:29:47.602]                           computeRestarts <- base::computeRestarts
[17:29:47.602]                           grepl <- base::grepl
[17:29:47.602]                           restarts <- computeRestarts(cond)
[17:29:47.602]                           for (restart in restarts) {
[17:29:47.602]                             name <- restart$name
[17:29:47.602]                             if (is.null(name)) 
[17:29:47.602]                               next
[17:29:47.602]                             if (!grepl(pattern, name)) 
[17:29:47.602]                               next
[17:29:47.602]                             invokeRestart(restart)
[17:29:47.602]                             muffled <- TRUE
[17:29:47.602]                             break
[17:29:47.602]                           }
[17:29:47.602]                         }
[17:29:47.602]                       }
[17:29:47.602]                       invisible(muffled)
[17:29:47.602]                     }
[17:29:47.602]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.602]                   }
[17:29:47.602]                 }
[17:29:47.602]             }
[17:29:47.602]         }))
[17:29:47.602]     }, error = function(ex) {
[17:29:47.602]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:47.602]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.602]                 ...future.rng), started = ...future.startTime, 
[17:29:47.602]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:47.602]             version = "1.8"), class = "FutureResult")
[17:29:47.602]     }, finally = {
[17:29:47.602]         if (!identical(...future.workdir, getwd())) 
[17:29:47.602]             setwd(...future.workdir)
[17:29:47.602]         {
[17:29:47.602]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:47.602]                 ...future.oldOptions$nwarnings <- NULL
[17:29:47.602]             }
[17:29:47.602]             base::options(...future.oldOptions)
[17:29:47.602]             if (.Platform$OS.type == "windows") {
[17:29:47.602]                 old_names <- names(...future.oldEnvVars)
[17:29:47.602]                 envs <- base::Sys.getenv()
[17:29:47.602]                 names <- names(envs)
[17:29:47.602]                 common <- intersect(names, old_names)
[17:29:47.602]                 added <- setdiff(names, old_names)
[17:29:47.602]                 removed <- setdiff(old_names, names)
[17:29:47.602]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:47.602]                   envs[common]]
[17:29:47.602]                 NAMES <- toupper(changed)
[17:29:47.602]                 args <- list()
[17:29:47.602]                 for (kk in seq_along(NAMES)) {
[17:29:47.602]                   name <- changed[[kk]]
[17:29:47.602]                   NAME <- NAMES[[kk]]
[17:29:47.602]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.602]                     next
[17:29:47.602]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.602]                 }
[17:29:47.602]                 NAMES <- toupper(added)
[17:29:47.602]                 for (kk in seq_along(NAMES)) {
[17:29:47.602]                   name <- added[[kk]]
[17:29:47.602]                   NAME <- NAMES[[kk]]
[17:29:47.602]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.602]                     next
[17:29:47.602]                   args[[name]] <- ""
[17:29:47.602]                 }
[17:29:47.602]                 NAMES <- toupper(removed)
[17:29:47.602]                 for (kk in seq_along(NAMES)) {
[17:29:47.602]                   name <- removed[[kk]]
[17:29:47.602]                   NAME <- NAMES[[kk]]
[17:29:47.602]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.602]                     next
[17:29:47.602]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.602]                 }
[17:29:47.602]                 if (length(args) > 0) 
[17:29:47.602]                   base::do.call(base::Sys.setenv, args = args)
[17:29:47.602]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:47.602]             }
[17:29:47.602]             else {
[17:29:47.602]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:47.602]             }
[17:29:47.602]             {
[17:29:47.602]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:47.602]                   0L) {
[17:29:47.602]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:47.602]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:47.602]                   base::options(opts)
[17:29:47.602]                 }
[17:29:47.602]                 {
[17:29:47.602]                   {
[17:29:47.602]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:47.602]                     NULL
[17:29:47.602]                   }
[17:29:47.602]                   options(future.plan = NULL)
[17:29:47.602]                   if (is.na(NA_character_)) 
[17:29:47.602]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.602]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:47.602]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:47.602]                     .init = FALSE)
[17:29:47.602]                 }
[17:29:47.602]             }
[17:29:47.602]         }
[17:29:47.602]     })
[17:29:47.602]     if (TRUE) {
[17:29:47.602]         base::sink(type = "output", split = FALSE)
[17:29:47.602]         if (TRUE) {
[17:29:47.602]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:47.602]         }
[17:29:47.602]         else {
[17:29:47.602]             ...future.result["stdout"] <- base::list(NULL)
[17:29:47.602]         }
[17:29:47.602]         base::close(...future.stdout)
[17:29:47.602]         ...future.stdout <- NULL
[17:29:47.602]     }
[17:29:47.602]     ...future.result$conditions <- ...future.conditions
[17:29:47.602]     ...future.result$finished <- base::Sys.time()
[17:29:47.602]     ...future.result
[17:29:47.602] }
[17:29:47.610] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:47.611] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:47.611] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:47.612] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:47.613] MultisessionFuture started
[17:29:47.613] - Launch lazy future ... done
[17:29:47.613] run() for 'MultisessionFuture' ... done
[17:29:47.615] getGlobalsAndPackages() ...
[17:29:47.615] Searching for globals...
[17:29:47.617] - globals found: [3] '{', 'sample', 'x'
[17:29:47.617] Searching for globals ... DONE
[17:29:47.618] Resolving globals: FALSE
[17:29:47.619] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:47.619] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:47.620] - globals: [1] 'x'
[17:29:47.620] 
[17:29:47.620] getGlobalsAndPackages() ... DONE
[17:29:47.621] run() for 'Future' ...
[17:29:47.621] - state: 'created'
[17:29:47.622] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:47.641] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:47.642] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:47.642]   - Field: 'node'
[17:29:47.643]   - Field: 'label'
[17:29:47.643]   - Field: 'local'
[17:29:47.643]   - Field: 'owner'
[17:29:47.644]   - Field: 'envir'
[17:29:47.644]   - Field: 'workers'
[17:29:47.644]   - Field: 'packages'
[17:29:47.645]   - Field: 'gc'
[17:29:47.645]   - Field: 'conditions'
[17:29:47.645]   - Field: 'persistent'
[17:29:47.646]   - Field: 'expr'
[17:29:47.646]   - Field: 'uuid'
[17:29:47.646]   - Field: 'seed'
[17:29:47.647]   - Field: 'version'
[17:29:47.647]   - Field: 'result'
[17:29:47.647]   - Field: 'asynchronous'
[17:29:47.648]   - Field: 'calls'
[17:29:47.648]   - Field: 'globals'
[17:29:47.648]   - Field: 'stdout'
[17:29:47.649]   - Field: 'earlySignal'
[17:29:47.649]   - Field: 'lazy'
[17:29:47.649]   - Field: 'state'
[17:29:47.650] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:47.650] - Launch lazy future ...
[17:29:47.651] Packages needed by the future expression (n = 0): <none>
[17:29:47.651] Packages needed by future strategies (n = 0): <none>
[17:29:47.652] {
[17:29:47.652]     {
[17:29:47.652]         {
[17:29:47.652]             ...future.startTime <- base::Sys.time()
[17:29:47.652]             {
[17:29:47.652]                 {
[17:29:47.652]                   {
[17:29:47.652]                     {
[17:29:47.652]                       base::local({
[17:29:47.652]                         has_future <- base::requireNamespace("future", 
[17:29:47.652]                           quietly = TRUE)
[17:29:47.652]                         if (has_future) {
[17:29:47.652]                           ns <- base::getNamespace("future")
[17:29:47.652]                           version <- ns[[".package"]][["version"]]
[17:29:47.652]                           if (is.null(version)) 
[17:29:47.652]                             version <- utils::packageVersion("future")
[17:29:47.652]                         }
[17:29:47.652]                         else {
[17:29:47.652]                           version <- NULL
[17:29:47.652]                         }
[17:29:47.652]                         if (!has_future || version < "1.8.0") {
[17:29:47.652]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:47.652]                             "", base::R.version$version.string), 
[17:29:47.652]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:47.652]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:47.652]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:47.652]                               "release", "version")], collapse = " "), 
[17:29:47.652]                             hostname = base::Sys.info()[["nodename"]])
[17:29:47.652]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:47.652]                             info)
[17:29:47.652]                           info <- base::paste(info, collapse = "; ")
[17:29:47.652]                           if (!has_future) {
[17:29:47.652]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:47.652]                               info)
[17:29:47.652]                           }
[17:29:47.652]                           else {
[17:29:47.652]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:47.652]                               info, version)
[17:29:47.652]                           }
[17:29:47.652]                           base::stop(msg)
[17:29:47.652]                         }
[17:29:47.652]                       })
[17:29:47.652]                     }
[17:29:47.652]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:47.652]                     base::options(mc.cores = 1L)
[17:29:47.652]                   }
[17:29:47.652]                   ...future.strategy.old <- future::plan("list")
[17:29:47.652]                   options(future.plan = NULL)
[17:29:47.652]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.652]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:47.652]                 }
[17:29:47.652]                 ...future.workdir <- getwd()
[17:29:47.652]             }
[17:29:47.652]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:47.652]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:47.652]         }
[17:29:47.652]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:47.652]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:47.652]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:47.652]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:47.652]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:47.652]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:47.652]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:47.652]             base::names(...future.oldOptions))
[17:29:47.652]     }
[17:29:47.652]     if (FALSE) {
[17:29:47.652]     }
[17:29:47.652]     else {
[17:29:47.652]         if (TRUE) {
[17:29:47.652]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:47.652]                 open = "w")
[17:29:47.652]         }
[17:29:47.652]         else {
[17:29:47.652]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:47.652]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:47.652]         }
[17:29:47.652]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:47.652]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:47.652]             base::sink(type = "output", split = FALSE)
[17:29:47.652]             base::close(...future.stdout)
[17:29:47.652]         }, add = TRUE)
[17:29:47.652]     }
[17:29:47.652]     ...future.frame <- base::sys.nframe()
[17:29:47.652]     ...future.conditions <- base::list()
[17:29:47.652]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:47.652]     if (FALSE) {
[17:29:47.652]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:47.652]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:47.652]     }
[17:29:47.652]     ...future.result <- base::tryCatch({
[17:29:47.652]         base::withCallingHandlers({
[17:29:47.652]             ...future.value <- base::withVisible(base::local({
[17:29:47.652]                 ...future.makeSendCondition <- base::local({
[17:29:47.652]                   sendCondition <- NULL
[17:29:47.652]                   function(frame = 1L) {
[17:29:47.652]                     if (is.function(sendCondition)) 
[17:29:47.652]                       return(sendCondition)
[17:29:47.652]                     ns <- getNamespace("parallel")
[17:29:47.652]                     if (exists("sendData", mode = "function", 
[17:29:47.652]                       envir = ns)) {
[17:29:47.652]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:47.652]                         envir = ns)
[17:29:47.652]                       envir <- sys.frame(frame)
[17:29:47.652]                       master <- NULL
[17:29:47.652]                       while (!identical(envir, .GlobalEnv) && 
[17:29:47.652]                         !identical(envir, emptyenv())) {
[17:29:47.652]                         if (exists("master", mode = "list", envir = envir, 
[17:29:47.652]                           inherits = FALSE)) {
[17:29:47.652]                           master <- get("master", mode = "list", 
[17:29:47.652]                             envir = envir, inherits = FALSE)
[17:29:47.652]                           if (inherits(master, c("SOCKnode", 
[17:29:47.652]                             "SOCK0node"))) {
[17:29:47.652]                             sendCondition <<- function(cond) {
[17:29:47.652]                               data <- list(type = "VALUE", value = cond, 
[17:29:47.652]                                 success = TRUE)
[17:29:47.652]                               parallel_sendData(master, data)
[17:29:47.652]                             }
[17:29:47.652]                             return(sendCondition)
[17:29:47.652]                           }
[17:29:47.652]                         }
[17:29:47.652]                         frame <- frame + 1L
[17:29:47.652]                         envir <- sys.frame(frame)
[17:29:47.652]                       }
[17:29:47.652]                     }
[17:29:47.652]                     sendCondition <<- function(cond) NULL
[17:29:47.652]                   }
[17:29:47.652]                 })
[17:29:47.652]                 withCallingHandlers({
[17:29:47.652]                   {
[17:29:47.652]                     sample(x, size = 1L)
[17:29:47.652]                   }
[17:29:47.652]                 }, immediateCondition = function(cond) {
[17:29:47.652]                   sendCondition <- ...future.makeSendCondition()
[17:29:47.652]                   sendCondition(cond)
[17:29:47.652]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.652]                   {
[17:29:47.652]                     inherits <- base::inherits
[17:29:47.652]                     invokeRestart <- base::invokeRestart
[17:29:47.652]                     is.null <- base::is.null
[17:29:47.652]                     muffled <- FALSE
[17:29:47.652]                     if (inherits(cond, "message")) {
[17:29:47.652]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:47.652]                       if (muffled) 
[17:29:47.652]                         invokeRestart("muffleMessage")
[17:29:47.652]                     }
[17:29:47.652]                     else if (inherits(cond, "warning")) {
[17:29:47.652]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:47.652]                       if (muffled) 
[17:29:47.652]                         invokeRestart("muffleWarning")
[17:29:47.652]                     }
[17:29:47.652]                     else if (inherits(cond, "condition")) {
[17:29:47.652]                       if (!is.null(pattern)) {
[17:29:47.652]                         computeRestarts <- base::computeRestarts
[17:29:47.652]                         grepl <- base::grepl
[17:29:47.652]                         restarts <- computeRestarts(cond)
[17:29:47.652]                         for (restart in restarts) {
[17:29:47.652]                           name <- restart$name
[17:29:47.652]                           if (is.null(name)) 
[17:29:47.652]                             next
[17:29:47.652]                           if (!grepl(pattern, name)) 
[17:29:47.652]                             next
[17:29:47.652]                           invokeRestart(restart)
[17:29:47.652]                           muffled <- TRUE
[17:29:47.652]                           break
[17:29:47.652]                         }
[17:29:47.652]                       }
[17:29:47.652]                     }
[17:29:47.652]                     invisible(muffled)
[17:29:47.652]                   }
[17:29:47.652]                   muffleCondition(cond)
[17:29:47.652]                 })
[17:29:47.652]             }))
[17:29:47.652]             future::FutureResult(value = ...future.value$value, 
[17:29:47.652]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.652]                   ...future.rng), globalenv = if (FALSE) 
[17:29:47.652]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:47.652]                     ...future.globalenv.names))
[17:29:47.652]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:47.652]         }, condition = base::local({
[17:29:47.652]             c <- base::c
[17:29:47.652]             inherits <- base::inherits
[17:29:47.652]             invokeRestart <- base::invokeRestart
[17:29:47.652]             length <- base::length
[17:29:47.652]             list <- base::list
[17:29:47.652]             seq.int <- base::seq.int
[17:29:47.652]             signalCondition <- base::signalCondition
[17:29:47.652]             sys.calls <- base::sys.calls
[17:29:47.652]             `[[` <- base::`[[`
[17:29:47.652]             `+` <- base::`+`
[17:29:47.652]             `<<-` <- base::`<<-`
[17:29:47.652]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:47.652]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:47.652]                   3L)]
[17:29:47.652]             }
[17:29:47.652]             function(cond) {
[17:29:47.652]                 is_error <- inherits(cond, "error")
[17:29:47.652]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:47.652]                   NULL)
[17:29:47.652]                 if (is_error) {
[17:29:47.652]                   sessionInformation <- function() {
[17:29:47.652]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:47.652]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:47.652]                       search = base::search(), system = base::Sys.info())
[17:29:47.652]                   }
[17:29:47.652]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.652]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:47.652]                     cond$call), session = sessionInformation(), 
[17:29:47.652]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:47.652]                   signalCondition(cond)
[17:29:47.652]                 }
[17:29:47.652]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:47.652]                 "immediateCondition"))) {
[17:29:47.652]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:47.652]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.652]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:47.652]                   if (TRUE && !signal) {
[17:29:47.652]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.652]                     {
[17:29:47.652]                       inherits <- base::inherits
[17:29:47.652]                       invokeRestart <- base::invokeRestart
[17:29:47.652]                       is.null <- base::is.null
[17:29:47.652]                       muffled <- FALSE
[17:29:47.652]                       if (inherits(cond, "message")) {
[17:29:47.652]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.652]                         if (muffled) 
[17:29:47.652]                           invokeRestart("muffleMessage")
[17:29:47.652]                       }
[17:29:47.652]                       else if (inherits(cond, "warning")) {
[17:29:47.652]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.652]                         if (muffled) 
[17:29:47.652]                           invokeRestart("muffleWarning")
[17:29:47.652]                       }
[17:29:47.652]                       else if (inherits(cond, "condition")) {
[17:29:47.652]                         if (!is.null(pattern)) {
[17:29:47.652]                           computeRestarts <- base::computeRestarts
[17:29:47.652]                           grepl <- base::grepl
[17:29:47.652]                           restarts <- computeRestarts(cond)
[17:29:47.652]                           for (restart in restarts) {
[17:29:47.652]                             name <- restart$name
[17:29:47.652]                             if (is.null(name)) 
[17:29:47.652]                               next
[17:29:47.652]                             if (!grepl(pattern, name)) 
[17:29:47.652]                               next
[17:29:47.652]                             invokeRestart(restart)
[17:29:47.652]                             muffled <- TRUE
[17:29:47.652]                             break
[17:29:47.652]                           }
[17:29:47.652]                         }
[17:29:47.652]                       }
[17:29:47.652]                       invisible(muffled)
[17:29:47.652]                     }
[17:29:47.652]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.652]                   }
[17:29:47.652]                 }
[17:29:47.652]                 else {
[17:29:47.652]                   if (TRUE) {
[17:29:47.652]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.652]                     {
[17:29:47.652]                       inherits <- base::inherits
[17:29:47.652]                       invokeRestart <- base::invokeRestart
[17:29:47.652]                       is.null <- base::is.null
[17:29:47.652]                       muffled <- FALSE
[17:29:47.652]                       if (inherits(cond, "message")) {
[17:29:47.652]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.652]                         if (muffled) 
[17:29:47.652]                           invokeRestart("muffleMessage")
[17:29:47.652]                       }
[17:29:47.652]                       else if (inherits(cond, "warning")) {
[17:29:47.652]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.652]                         if (muffled) 
[17:29:47.652]                           invokeRestart("muffleWarning")
[17:29:47.652]                       }
[17:29:47.652]                       else if (inherits(cond, "condition")) {
[17:29:47.652]                         if (!is.null(pattern)) {
[17:29:47.652]                           computeRestarts <- base::computeRestarts
[17:29:47.652]                           grepl <- base::grepl
[17:29:47.652]                           restarts <- computeRestarts(cond)
[17:29:47.652]                           for (restart in restarts) {
[17:29:47.652]                             name <- restart$name
[17:29:47.652]                             if (is.null(name)) 
[17:29:47.652]                               next
[17:29:47.652]                             if (!grepl(pattern, name)) 
[17:29:47.652]                               next
[17:29:47.652]                             invokeRestart(restart)
[17:29:47.652]                             muffled <- TRUE
[17:29:47.652]                             break
[17:29:47.652]                           }
[17:29:47.652]                         }
[17:29:47.652]                       }
[17:29:47.652]                       invisible(muffled)
[17:29:47.652]                     }
[17:29:47.652]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.652]                   }
[17:29:47.652]                 }
[17:29:47.652]             }
[17:29:47.652]         }))
[17:29:47.652]     }, error = function(ex) {
[17:29:47.652]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:47.652]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.652]                 ...future.rng), started = ...future.startTime, 
[17:29:47.652]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:47.652]             version = "1.8"), class = "FutureResult")
[17:29:47.652]     }, finally = {
[17:29:47.652]         if (!identical(...future.workdir, getwd())) 
[17:29:47.652]             setwd(...future.workdir)
[17:29:47.652]         {
[17:29:47.652]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:47.652]                 ...future.oldOptions$nwarnings <- NULL
[17:29:47.652]             }
[17:29:47.652]             base::options(...future.oldOptions)
[17:29:47.652]             if (.Platform$OS.type == "windows") {
[17:29:47.652]                 old_names <- names(...future.oldEnvVars)
[17:29:47.652]                 envs <- base::Sys.getenv()
[17:29:47.652]                 names <- names(envs)
[17:29:47.652]                 common <- intersect(names, old_names)
[17:29:47.652]                 added <- setdiff(names, old_names)
[17:29:47.652]                 removed <- setdiff(old_names, names)
[17:29:47.652]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:47.652]                   envs[common]]
[17:29:47.652]                 NAMES <- toupper(changed)
[17:29:47.652]                 args <- list()
[17:29:47.652]                 for (kk in seq_along(NAMES)) {
[17:29:47.652]                   name <- changed[[kk]]
[17:29:47.652]                   NAME <- NAMES[[kk]]
[17:29:47.652]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.652]                     next
[17:29:47.652]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.652]                 }
[17:29:47.652]                 NAMES <- toupper(added)
[17:29:47.652]                 for (kk in seq_along(NAMES)) {
[17:29:47.652]                   name <- added[[kk]]
[17:29:47.652]                   NAME <- NAMES[[kk]]
[17:29:47.652]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.652]                     next
[17:29:47.652]                   args[[name]] <- ""
[17:29:47.652]                 }
[17:29:47.652]                 NAMES <- toupper(removed)
[17:29:47.652]                 for (kk in seq_along(NAMES)) {
[17:29:47.652]                   name <- removed[[kk]]
[17:29:47.652]                   NAME <- NAMES[[kk]]
[17:29:47.652]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.652]                     next
[17:29:47.652]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.652]                 }
[17:29:47.652]                 if (length(args) > 0) 
[17:29:47.652]                   base::do.call(base::Sys.setenv, args = args)
[17:29:47.652]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:47.652]             }
[17:29:47.652]             else {
[17:29:47.652]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:47.652]             }
[17:29:47.652]             {
[17:29:47.652]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:47.652]                   0L) {
[17:29:47.652]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:47.652]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:47.652]                   base::options(opts)
[17:29:47.652]                 }
[17:29:47.652]                 {
[17:29:47.652]                   {
[17:29:47.652]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:47.652]                     NULL
[17:29:47.652]                   }
[17:29:47.652]                   options(future.plan = NULL)
[17:29:47.652]                   if (is.na(NA_character_)) 
[17:29:47.652]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.652]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:47.652]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:47.652]                     .init = FALSE)
[17:29:47.652]                 }
[17:29:47.652]             }
[17:29:47.652]         }
[17:29:47.652]     })
[17:29:47.652]     if (TRUE) {
[17:29:47.652]         base::sink(type = "output", split = FALSE)
[17:29:47.652]         if (TRUE) {
[17:29:47.652]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:47.652]         }
[17:29:47.652]         else {
[17:29:47.652]             ...future.result["stdout"] <- base::list(NULL)
[17:29:47.652]         }
[17:29:47.652]         base::close(...future.stdout)
[17:29:47.652]         ...future.stdout <- NULL
[17:29:47.652]     }
[17:29:47.652]     ...future.result$conditions <- ...future.conditions
[17:29:47.652]     ...future.result$finished <- base::Sys.time()
[17:29:47.652]     ...future.result
[17:29:47.652] }
[17:29:47.661] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:47.661] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:47.662] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:47.663] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:47.664] MultisessionFuture started
[17:29:47.665] - Launch lazy future ... done
[17:29:47.665] run() for 'MultisessionFuture' ... done
[17:29:47.666] getGlobalsAndPackages() ...
[17:29:47.667] Searching for globals...
[17:29:47.670] - globals found: [3] '{', 'sample', 'x'
[17:29:47.671] Searching for globals ... DONE
[17:29:47.671] Resolving globals: FALSE
[17:29:47.672] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:47.673] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:47.673] - globals: [1] 'x'
[17:29:47.674] 
[17:29:47.674] getGlobalsAndPackages() ... DONE
[17:29:47.675] run() for 'Future' ...
[17:29:47.675] - state: 'created'
[17:29:47.675] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:47.694] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:47.695] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:47.695]   - Field: 'node'
[17:29:47.695]   - Field: 'label'
[17:29:47.695]   - Field: 'local'
[17:29:47.696]   - Field: 'owner'
[17:29:47.696]   - Field: 'envir'
[17:29:47.696]   - Field: 'workers'
[17:29:47.696]   - Field: 'packages'
[17:29:47.696]   - Field: 'gc'
[17:29:47.696]   - Field: 'conditions'
[17:29:47.697]   - Field: 'persistent'
[17:29:47.697]   - Field: 'expr'
[17:29:47.697]   - Field: 'uuid'
[17:29:47.698]   - Field: 'seed'
[17:29:47.698]   - Field: 'version'
[17:29:47.698]   - Field: 'result'
[17:29:47.698]   - Field: 'asynchronous'
[17:29:47.699]   - Field: 'calls'
[17:29:47.699]   - Field: 'globals'
[17:29:47.699]   - Field: 'stdout'
[17:29:47.700]   - Field: 'earlySignal'
[17:29:47.700]   - Field: 'lazy'
[17:29:47.700]   - Field: 'state'
[17:29:47.701] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:47.701] - Launch lazy future ...
[17:29:47.702] Packages needed by the future expression (n = 0): <none>
[17:29:47.702] Packages needed by future strategies (n = 0): <none>
[17:29:47.703] {
[17:29:47.703]     {
[17:29:47.703]         {
[17:29:47.703]             ...future.startTime <- base::Sys.time()
[17:29:47.703]             {
[17:29:47.703]                 {
[17:29:47.703]                   {
[17:29:47.703]                     {
[17:29:47.703]                       base::local({
[17:29:47.703]                         has_future <- base::requireNamespace("future", 
[17:29:47.703]                           quietly = TRUE)
[17:29:47.703]                         if (has_future) {
[17:29:47.703]                           ns <- base::getNamespace("future")
[17:29:47.703]                           version <- ns[[".package"]][["version"]]
[17:29:47.703]                           if (is.null(version)) 
[17:29:47.703]                             version <- utils::packageVersion("future")
[17:29:47.703]                         }
[17:29:47.703]                         else {
[17:29:47.703]                           version <- NULL
[17:29:47.703]                         }
[17:29:47.703]                         if (!has_future || version < "1.8.0") {
[17:29:47.703]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:47.703]                             "", base::R.version$version.string), 
[17:29:47.703]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:47.703]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:47.703]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:47.703]                               "release", "version")], collapse = " "), 
[17:29:47.703]                             hostname = base::Sys.info()[["nodename"]])
[17:29:47.703]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:47.703]                             info)
[17:29:47.703]                           info <- base::paste(info, collapse = "; ")
[17:29:47.703]                           if (!has_future) {
[17:29:47.703]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:47.703]                               info)
[17:29:47.703]                           }
[17:29:47.703]                           else {
[17:29:47.703]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:47.703]                               info, version)
[17:29:47.703]                           }
[17:29:47.703]                           base::stop(msg)
[17:29:47.703]                         }
[17:29:47.703]                       })
[17:29:47.703]                     }
[17:29:47.703]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:47.703]                     base::options(mc.cores = 1L)
[17:29:47.703]                   }
[17:29:47.703]                   ...future.strategy.old <- future::plan("list")
[17:29:47.703]                   options(future.plan = NULL)
[17:29:47.703]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.703]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:47.703]                 }
[17:29:47.703]                 ...future.workdir <- getwd()
[17:29:47.703]             }
[17:29:47.703]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:47.703]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:47.703]         }
[17:29:47.703]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:47.703]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:47.703]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:47.703]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:47.703]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:47.703]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:47.703]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:47.703]             base::names(...future.oldOptions))
[17:29:47.703]     }
[17:29:47.703]     if (FALSE) {
[17:29:47.703]     }
[17:29:47.703]     else {
[17:29:47.703]         if (TRUE) {
[17:29:47.703]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:47.703]                 open = "w")
[17:29:47.703]         }
[17:29:47.703]         else {
[17:29:47.703]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:47.703]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:47.703]         }
[17:29:47.703]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:47.703]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:47.703]             base::sink(type = "output", split = FALSE)
[17:29:47.703]             base::close(...future.stdout)
[17:29:47.703]         }, add = TRUE)
[17:29:47.703]     }
[17:29:47.703]     ...future.frame <- base::sys.nframe()
[17:29:47.703]     ...future.conditions <- base::list()
[17:29:47.703]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:47.703]     if (FALSE) {
[17:29:47.703]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:47.703]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:47.703]     }
[17:29:47.703]     ...future.result <- base::tryCatch({
[17:29:47.703]         base::withCallingHandlers({
[17:29:47.703]             ...future.value <- base::withVisible(base::local({
[17:29:47.703]                 ...future.makeSendCondition <- base::local({
[17:29:47.703]                   sendCondition <- NULL
[17:29:47.703]                   function(frame = 1L) {
[17:29:47.703]                     if (is.function(sendCondition)) 
[17:29:47.703]                       return(sendCondition)
[17:29:47.703]                     ns <- getNamespace("parallel")
[17:29:47.703]                     if (exists("sendData", mode = "function", 
[17:29:47.703]                       envir = ns)) {
[17:29:47.703]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:47.703]                         envir = ns)
[17:29:47.703]                       envir <- sys.frame(frame)
[17:29:47.703]                       master <- NULL
[17:29:47.703]                       while (!identical(envir, .GlobalEnv) && 
[17:29:47.703]                         !identical(envir, emptyenv())) {
[17:29:47.703]                         if (exists("master", mode = "list", envir = envir, 
[17:29:47.703]                           inherits = FALSE)) {
[17:29:47.703]                           master <- get("master", mode = "list", 
[17:29:47.703]                             envir = envir, inherits = FALSE)
[17:29:47.703]                           if (inherits(master, c("SOCKnode", 
[17:29:47.703]                             "SOCK0node"))) {
[17:29:47.703]                             sendCondition <<- function(cond) {
[17:29:47.703]                               data <- list(type = "VALUE", value = cond, 
[17:29:47.703]                                 success = TRUE)
[17:29:47.703]                               parallel_sendData(master, data)
[17:29:47.703]                             }
[17:29:47.703]                             return(sendCondition)
[17:29:47.703]                           }
[17:29:47.703]                         }
[17:29:47.703]                         frame <- frame + 1L
[17:29:47.703]                         envir <- sys.frame(frame)
[17:29:47.703]                       }
[17:29:47.703]                     }
[17:29:47.703]                     sendCondition <<- function(cond) NULL
[17:29:47.703]                   }
[17:29:47.703]                 })
[17:29:47.703]                 withCallingHandlers({
[17:29:47.703]                   {
[17:29:47.703]                     sample(x, size = 1L)
[17:29:47.703]                   }
[17:29:47.703]                 }, immediateCondition = function(cond) {
[17:29:47.703]                   sendCondition <- ...future.makeSendCondition()
[17:29:47.703]                   sendCondition(cond)
[17:29:47.703]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.703]                   {
[17:29:47.703]                     inherits <- base::inherits
[17:29:47.703]                     invokeRestart <- base::invokeRestart
[17:29:47.703]                     is.null <- base::is.null
[17:29:47.703]                     muffled <- FALSE
[17:29:47.703]                     if (inherits(cond, "message")) {
[17:29:47.703]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:47.703]                       if (muffled) 
[17:29:47.703]                         invokeRestart("muffleMessage")
[17:29:47.703]                     }
[17:29:47.703]                     else if (inherits(cond, "warning")) {
[17:29:47.703]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:47.703]                       if (muffled) 
[17:29:47.703]                         invokeRestart("muffleWarning")
[17:29:47.703]                     }
[17:29:47.703]                     else if (inherits(cond, "condition")) {
[17:29:47.703]                       if (!is.null(pattern)) {
[17:29:47.703]                         computeRestarts <- base::computeRestarts
[17:29:47.703]                         grepl <- base::grepl
[17:29:47.703]                         restarts <- computeRestarts(cond)
[17:29:47.703]                         for (restart in restarts) {
[17:29:47.703]                           name <- restart$name
[17:29:47.703]                           if (is.null(name)) 
[17:29:47.703]                             next
[17:29:47.703]                           if (!grepl(pattern, name)) 
[17:29:47.703]                             next
[17:29:47.703]                           invokeRestart(restart)
[17:29:47.703]                           muffled <- TRUE
[17:29:47.703]                           break
[17:29:47.703]                         }
[17:29:47.703]                       }
[17:29:47.703]                     }
[17:29:47.703]                     invisible(muffled)
[17:29:47.703]                   }
[17:29:47.703]                   muffleCondition(cond)
[17:29:47.703]                 })
[17:29:47.703]             }))
[17:29:47.703]             future::FutureResult(value = ...future.value$value, 
[17:29:47.703]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.703]                   ...future.rng), globalenv = if (FALSE) 
[17:29:47.703]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:47.703]                     ...future.globalenv.names))
[17:29:47.703]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:47.703]         }, condition = base::local({
[17:29:47.703]             c <- base::c
[17:29:47.703]             inherits <- base::inherits
[17:29:47.703]             invokeRestart <- base::invokeRestart
[17:29:47.703]             length <- base::length
[17:29:47.703]             list <- base::list
[17:29:47.703]             seq.int <- base::seq.int
[17:29:47.703]             signalCondition <- base::signalCondition
[17:29:47.703]             sys.calls <- base::sys.calls
[17:29:47.703]             `[[` <- base::`[[`
[17:29:47.703]             `+` <- base::`+`
[17:29:47.703]             `<<-` <- base::`<<-`
[17:29:47.703]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:47.703]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:47.703]                   3L)]
[17:29:47.703]             }
[17:29:47.703]             function(cond) {
[17:29:47.703]                 is_error <- inherits(cond, "error")
[17:29:47.703]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:47.703]                   NULL)
[17:29:47.703]                 if (is_error) {
[17:29:47.703]                   sessionInformation <- function() {
[17:29:47.703]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:47.703]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:47.703]                       search = base::search(), system = base::Sys.info())
[17:29:47.703]                   }
[17:29:47.703]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.703]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:47.703]                     cond$call), session = sessionInformation(), 
[17:29:47.703]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:47.703]                   signalCondition(cond)
[17:29:47.703]                 }
[17:29:47.703]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:47.703]                 "immediateCondition"))) {
[17:29:47.703]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:47.703]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.703]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:47.703]                   if (TRUE && !signal) {
[17:29:47.703]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.703]                     {
[17:29:47.703]                       inherits <- base::inherits
[17:29:47.703]                       invokeRestart <- base::invokeRestart
[17:29:47.703]                       is.null <- base::is.null
[17:29:47.703]                       muffled <- FALSE
[17:29:47.703]                       if (inherits(cond, "message")) {
[17:29:47.703]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.703]                         if (muffled) 
[17:29:47.703]                           invokeRestart("muffleMessage")
[17:29:47.703]                       }
[17:29:47.703]                       else if (inherits(cond, "warning")) {
[17:29:47.703]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.703]                         if (muffled) 
[17:29:47.703]                           invokeRestart("muffleWarning")
[17:29:47.703]                       }
[17:29:47.703]                       else if (inherits(cond, "condition")) {
[17:29:47.703]                         if (!is.null(pattern)) {
[17:29:47.703]                           computeRestarts <- base::computeRestarts
[17:29:47.703]                           grepl <- base::grepl
[17:29:47.703]                           restarts <- computeRestarts(cond)
[17:29:47.703]                           for (restart in restarts) {
[17:29:47.703]                             name <- restart$name
[17:29:47.703]                             if (is.null(name)) 
[17:29:47.703]                               next
[17:29:47.703]                             if (!grepl(pattern, name)) 
[17:29:47.703]                               next
[17:29:47.703]                             invokeRestart(restart)
[17:29:47.703]                             muffled <- TRUE
[17:29:47.703]                             break
[17:29:47.703]                           }
[17:29:47.703]                         }
[17:29:47.703]                       }
[17:29:47.703]                       invisible(muffled)
[17:29:47.703]                     }
[17:29:47.703]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.703]                   }
[17:29:47.703]                 }
[17:29:47.703]                 else {
[17:29:47.703]                   if (TRUE) {
[17:29:47.703]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.703]                     {
[17:29:47.703]                       inherits <- base::inherits
[17:29:47.703]                       invokeRestart <- base::invokeRestart
[17:29:47.703]                       is.null <- base::is.null
[17:29:47.703]                       muffled <- FALSE
[17:29:47.703]                       if (inherits(cond, "message")) {
[17:29:47.703]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.703]                         if (muffled) 
[17:29:47.703]                           invokeRestart("muffleMessage")
[17:29:47.703]                       }
[17:29:47.703]                       else if (inherits(cond, "warning")) {
[17:29:47.703]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.703]                         if (muffled) 
[17:29:47.703]                           invokeRestart("muffleWarning")
[17:29:47.703]                       }
[17:29:47.703]                       else if (inherits(cond, "condition")) {
[17:29:47.703]                         if (!is.null(pattern)) {
[17:29:47.703]                           computeRestarts <- base::computeRestarts
[17:29:47.703]                           grepl <- base::grepl
[17:29:47.703]                           restarts <- computeRestarts(cond)
[17:29:47.703]                           for (restart in restarts) {
[17:29:47.703]                             name <- restart$name
[17:29:47.703]                             if (is.null(name)) 
[17:29:47.703]                               next
[17:29:47.703]                             if (!grepl(pattern, name)) 
[17:29:47.703]                               next
[17:29:47.703]                             invokeRestart(restart)
[17:29:47.703]                             muffled <- TRUE
[17:29:47.703]                             break
[17:29:47.703]                           }
[17:29:47.703]                         }
[17:29:47.703]                       }
[17:29:47.703]                       invisible(muffled)
[17:29:47.703]                     }
[17:29:47.703]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.703]                   }
[17:29:47.703]                 }
[17:29:47.703]             }
[17:29:47.703]         }))
[17:29:47.703]     }, error = function(ex) {
[17:29:47.703]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:47.703]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.703]                 ...future.rng), started = ...future.startTime, 
[17:29:47.703]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:47.703]             version = "1.8"), class = "FutureResult")
[17:29:47.703]     }, finally = {
[17:29:47.703]         if (!identical(...future.workdir, getwd())) 
[17:29:47.703]             setwd(...future.workdir)
[17:29:47.703]         {
[17:29:47.703]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:47.703]                 ...future.oldOptions$nwarnings <- NULL
[17:29:47.703]             }
[17:29:47.703]             base::options(...future.oldOptions)
[17:29:47.703]             if (.Platform$OS.type == "windows") {
[17:29:47.703]                 old_names <- names(...future.oldEnvVars)
[17:29:47.703]                 envs <- base::Sys.getenv()
[17:29:47.703]                 names <- names(envs)
[17:29:47.703]                 common <- intersect(names, old_names)
[17:29:47.703]                 added <- setdiff(names, old_names)
[17:29:47.703]                 removed <- setdiff(old_names, names)
[17:29:47.703]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:47.703]                   envs[common]]
[17:29:47.703]                 NAMES <- toupper(changed)
[17:29:47.703]                 args <- list()
[17:29:47.703]                 for (kk in seq_along(NAMES)) {
[17:29:47.703]                   name <- changed[[kk]]
[17:29:47.703]                   NAME <- NAMES[[kk]]
[17:29:47.703]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.703]                     next
[17:29:47.703]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.703]                 }
[17:29:47.703]                 NAMES <- toupper(added)
[17:29:47.703]                 for (kk in seq_along(NAMES)) {
[17:29:47.703]                   name <- added[[kk]]
[17:29:47.703]                   NAME <- NAMES[[kk]]
[17:29:47.703]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.703]                     next
[17:29:47.703]                   args[[name]] <- ""
[17:29:47.703]                 }
[17:29:47.703]                 NAMES <- toupper(removed)
[17:29:47.703]                 for (kk in seq_along(NAMES)) {
[17:29:47.703]                   name <- removed[[kk]]
[17:29:47.703]                   NAME <- NAMES[[kk]]
[17:29:47.703]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.703]                     next
[17:29:47.703]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.703]                 }
[17:29:47.703]                 if (length(args) > 0) 
[17:29:47.703]                   base::do.call(base::Sys.setenv, args = args)
[17:29:47.703]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:47.703]             }
[17:29:47.703]             else {
[17:29:47.703]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:47.703]             }
[17:29:47.703]             {
[17:29:47.703]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:47.703]                   0L) {
[17:29:47.703]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:47.703]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:47.703]                   base::options(opts)
[17:29:47.703]                 }
[17:29:47.703]                 {
[17:29:47.703]                   {
[17:29:47.703]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:47.703]                     NULL
[17:29:47.703]                   }
[17:29:47.703]                   options(future.plan = NULL)
[17:29:47.703]                   if (is.na(NA_character_)) 
[17:29:47.703]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.703]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:47.703]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:47.703]                     .init = FALSE)
[17:29:47.703]                 }
[17:29:47.703]             }
[17:29:47.703]         }
[17:29:47.703]     })
[17:29:47.703]     if (TRUE) {
[17:29:47.703]         base::sink(type = "output", split = FALSE)
[17:29:47.703]         if (TRUE) {
[17:29:47.703]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:47.703]         }
[17:29:47.703]         else {
[17:29:47.703]             ...future.result["stdout"] <- base::list(NULL)
[17:29:47.703]         }
[17:29:47.703]         base::close(...future.stdout)
[17:29:47.703]         ...future.stdout <- NULL
[17:29:47.703]     }
[17:29:47.703]     ...future.result$conditions <- ...future.conditions
[17:29:47.703]     ...future.result$finished <- base::Sys.time()
[17:29:47.703]     ...future.result
[17:29:47.703] }
[17:29:47.709] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:47.723] receiveMessageFromWorker() for ClusterFuture ...
[17:29:47.724] - Validating connection of MultisessionFuture
[17:29:47.724] - received message: FutureResult
[17:29:47.725] - Received FutureResult
[17:29:47.725] - Erased future from FutureRegistry
[17:29:47.725] result() for ClusterFuture ...
[17:29:47.726] - result already collected: FutureResult
[17:29:47.726] result() for ClusterFuture ... done
[17:29:47.726] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:47.727] result() for ClusterFuture ...
[17:29:47.727] - result already collected: FutureResult
[17:29:47.727] result() for ClusterFuture ... done
[17:29:47.728] result() for ClusterFuture ...
[17:29:47.728] - result already collected: FutureResult
[17:29:47.728] result() for ClusterFuture ... done
[17:29:47.730] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:47.730] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:47.731] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:47.731] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:47.732] MultisessionFuture started
[17:29:47.733] - Launch lazy future ... done
[17:29:47.733] run() for 'MultisessionFuture' ... done
[17:29:47.734] getGlobalsAndPackages() ...
[17:29:47.734] Searching for globals...
[17:29:47.737] - globals found: [3] '{', 'sample', 'x'
[17:29:47.737] Searching for globals ... DONE
[17:29:47.737] Resolving globals: FALSE
[17:29:47.738] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:47.739] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:47.739] - globals: [1] 'x'
[17:29:47.740] 
[17:29:47.740] getGlobalsAndPackages() ... DONE
[17:29:47.741] run() for 'Future' ...
[17:29:47.741] - state: 'created'
[17:29:47.741] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:47.761] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:47.762] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:47.762]   - Field: 'node'
[17:29:47.763]   - Field: 'label'
[17:29:47.763]   - Field: 'local'
[17:29:47.763]   - Field: 'owner'
[17:29:47.764]   - Field: 'envir'
[17:29:47.764]   - Field: 'workers'
[17:29:47.764]   - Field: 'packages'
[17:29:47.765]   - Field: 'gc'
[17:29:47.765]   - Field: 'conditions'
[17:29:47.765]   - Field: 'persistent'
[17:29:47.766]   - Field: 'expr'
[17:29:47.766]   - Field: 'uuid'
[17:29:47.766]   - Field: 'seed'
[17:29:47.767]   - Field: 'version'
[17:29:47.767]   - Field: 'result'
[17:29:47.767]   - Field: 'asynchronous'
[17:29:47.767]   - Field: 'calls'
[17:29:47.768]   - Field: 'globals'
[17:29:47.768]   - Field: 'stdout'
[17:29:47.768]   - Field: 'earlySignal'
[17:29:47.769]   - Field: 'lazy'
[17:29:47.769]   - Field: 'state'
[17:29:47.769] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:47.769] - Launch lazy future ...
[17:29:47.770] Packages needed by the future expression (n = 0): <none>
[17:29:47.770] Packages needed by future strategies (n = 0): <none>
[17:29:47.771] {
[17:29:47.771]     {
[17:29:47.771]         {
[17:29:47.771]             ...future.startTime <- base::Sys.time()
[17:29:47.771]             {
[17:29:47.771]                 {
[17:29:47.771]                   {
[17:29:47.771]                     {
[17:29:47.771]                       base::local({
[17:29:47.771]                         has_future <- base::requireNamespace("future", 
[17:29:47.771]                           quietly = TRUE)
[17:29:47.771]                         if (has_future) {
[17:29:47.771]                           ns <- base::getNamespace("future")
[17:29:47.771]                           version <- ns[[".package"]][["version"]]
[17:29:47.771]                           if (is.null(version)) 
[17:29:47.771]                             version <- utils::packageVersion("future")
[17:29:47.771]                         }
[17:29:47.771]                         else {
[17:29:47.771]                           version <- NULL
[17:29:47.771]                         }
[17:29:47.771]                         if (!has_future || version < "1.8.0") {
[17:29:47.771]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:47.771]                             "", base::R.version$version.string), 
[17:29:47.771]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:47.771]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:47.771]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:47.771]                               "release", "version")], collapse = " "), 
[17:29:47.771]                             hostname = base::Sys.info()[["nodename"]])
[17:29:47.771]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:47.771]                             info)
[17:29:47.771]                           info <- base::paste(info, collapse = "; ")
[17:29:47.771]                           if (!has_future) {
[17:29:47.771]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:47.771]                               info)
[17:29:47.771]                           }
[17:29:47.771]                           else {
[17:29:47.771]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:47.771]                               info, version)
[17:29:47.771]                           }
[17:29:47.771]                           base::stop(msg)
[17:29:47.771]                         }
[17:29:47.771]                       })
[17:29:47.771]                     }
[17:29:47.771]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:47.771]                     base::options(mc.cores = 1L)
[17:29:47.771]                   }
[17:29:47.771]                   ...future.strategy.old <- future::plan("list")
[17:29:47.771]                   options(future.plan = NULL)
[17:29:47.771]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.771]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:47.771]                 }
[17:29:47.771]                 ...future.workdir <- getwd()
[17:29:47.771]             }
[17:29:47.771]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:47.771]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:47.771]         }
[17:29:47.771]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:47.771]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:47.771]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:47.771]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:47.771]             future.rng.onMisuse = "ignore", future.rng.onMisuse.keepFuture = NULL, 
[17:29:47.771]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:47.771]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:47.771]             base::names(...future.oldOptions))
[17:29:47.771]     }
[17:29:47.771]     if (FALSE) {
[17:29:47.771]     }
[17:29:47.771]     else {
[17:29:47.771]         if (TRUE) {
[17:29:47.771]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:47.771]                 open = "w")
[17:29:47.771]         }
[17:29:47.771]         else {
[17:29:47.771]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:47.771]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:47.771]         }
[17:29:47.771]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:47.771]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:47.771]             base::sink(type = "output", split = FALSE)
[17:29:47.771]             base::close(...future.stdout)
[17:29:47.771]         }, add = TRUE)
[17:29:47.771]     }
[17:29:47.771]     ...future.frame <- base::sys.nframe()
[17:29:47.771]     ...future.conditions <- base::list()
[17:29:47.771]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:47.771]     if (FALSE) {
[17:29:47.771]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:47.771]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:47.771]     }
[17:29:47.771]     ...future.result <- base::tryCatch({
[17:29:47.771]         base::withCallingHandlers({
[17:29:47.771]             ...future.value <- base::withVisible(base::local({
[17:29:47.771]                 ...future.makeSendCondition <- base::local({
[17:29:47.771]                   sendCondition <- NULL
[17:29:47.771]                   function(frame = 1L) {
[17:29:47.771]                     if (is.function(sendCondition)) 
[17:29:47.771]                       return(sendCondition)
[17:29:47.771]                     ns <- getNamespace("parallel")
[17:29:47.771]                     if (exists("sendData", mode = "function", 
[17:29:47.771]                       envir = ns)) {
[17:29:47.771]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:47.771]                         envir = ns)
[17:29:47.771]                       envir <- sys.frame(frame)
[17:29:47.771]                       master <- NULL
[17:29:47.771]                       while (!identical(envir, .GlobalEnv) && 
[17:29:47.771]                         !identical(envir, emptyenv())) {
[17:29:47.771]                         if (exists("master", mode = "list", envir = envir, 
[17:29:47.771]                           inherits = FALSE)) {
[17:29:47.771]                           master <- get("master", mode = "list", 
[17:29:47.771]                             envir = envir, inherits = FALSE)
[17:29:47.771]                           if (inherits(master, c("SOCKnode", 
[17:29:47.771]                             "SOCK0node"))) {
[17:29:47.771]                             sendCondition <<- function(cond) {
[17:29:47.771]                               data <- list(type = "VALUE", value = cond, 
[17:29:47.771]                                 success = TRUE)
[17:29:47.771]                               parallel_sendData(master, data)
[17:29:47.771]                             }
[17:29:47.771]                             return(sendCondition)
[17:29:47.771]                           }
[17:29:47.771]                         }
[17:29:47.771]                         frame <- frame + 1L
[17:29:47.771]                         envir <- sys.frame(frame)
[17:29:47.771]                       }
[17:29:47.771]                     }
[17:29:47.771]                     sendCondition <<- function(cond) NULL
[17:29:47.771]                   }
[17:29:47.771]                 })
[17:29:47.771]                 withCallingHandlers({
[17:29:47.771]                   {
[17:29:47.771]                     sample(x, size = 1L)
[17:29:47.771]                   }
[17:29:47.771]                 }, immediateCondition = function(cond) {
[17:29:47.771]                   sendCondition <- ...future.makeSendCondition()
[17:29:47.771]                   sendCondition(cond)
[17:29:47.771]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.771]                   {
[17:29:47.771]                     inherits <- base::inherits
[17:29:47.771]                     invokeRestart <- base::invokeRestart
[17:29:47.771]                     is.null <- base::is.null
[17:29:47.771]                     muffled <- FALSE
[17:29:47.771]                     if (inherits(cond, "message")) {
[17:29:47.771]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:47.771]                       if (muffled) 
[17:29:47.771]                         invokeRestart("muffleMessage")
[17:29:47.771]                     }
[17:29:47.771]                     else if (inherits(cond, "warning")) {
[17:29:47.771]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:47.771]                       if (muffled) 
[17:29:47.771]                         invokeRestart("muffleWarning")
[17:29:47.771]                     }
[17:29:47.771]                     else if (inherits(cond, "condition")) {
[17:29:47.771]                       if (!is.null(pattern)) {
[17:29:47.771]                         computeRestarts <- base::computeRestarts
[17:29:47.771]                         grepl <- base::grepl
[17:29:47.771]                         restarts <- computeRestarts(cond)
[17:29:47.771]                         for (restart in restarts) {
[17:29:47.771]                           name <- restart$name
[17:29:47.771]                           if (is.null(name)) 
[17:29:47.771]                             next
[17:29:47.771]                           if (!grepl(pattern, name)) 
[17:29:47.771]                             next
[17:29:47.771]                           invokeRestart(restart)
[17:29:47.771]                           muffled <- TRUE
[17:29:47.771]                           break
[17:29:47.771]                         }
[17:29:47.771]                       }
[17:29:47.771]                     }
[17:29:47.771]                     invisible(muffled)
[17:29:47.771]                   }
[17:29:47.771]                   muffleCondition(cond)
[17:29:47.771]                 })
[17:29:47.771]             }))
[17:29:47.771]             future::FutureResult(value = ...future.value$value, 
[17:29:47.771]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.771]                   ...future.rng), globalenv = if (FALSE) 
[17:29:47.771]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:47.771]                     ...future.globalenv.names))
[17:29:47.771]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:47.771]         }, condition = base::local({
[17:29:47.771]             c <- base::c
[17:29:47.771]             inherits <- base::inherits
[17:29:47.771]             invokeRestart <- base::invokeRestart
[17:29:47.771]             length <- base::length
[17:29:47.771]             list <- base::list
[17:29:47.771]             seq.int <- base::seq.int
[17:29:47.771]             signalCondition <- base::signalCondition
[17:29:47.771]             sys.calls <- base::sys.calls
[17:29:47.771]             `[[` <- base::`[[`
[17:29:47.771]             `+` <- base::`+`
[17:29:47.771]             `<<-` <- base::`<<-`
[17:29:47.771]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:47.771]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:47.771]                   3L)]
[17:29:47.771]             }
[17:29:47.771]             function(cond) {
[17:29:47.771]                 is_error <- inherits(cond, "error")
[17:29:47.771]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:47.771]                   NULL)
[17:29:47.771]                 if (is_error) {
[17:29:47.771]                   sessionInformation <- function() {
[17:29:47.771]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:47.771]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:47.771]                       search = base::search(), system = base::Sys.info())
[17:29:47.771]                   }
[17:29:47.771]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.771]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:47.771]                     cond$call), session = sessionInformation(), 
[17:29:47.771]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:47.771]                   signalCondition(cond)
[17:29:47.771]                 }
[17:29:47.771]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:47.771]                 "immediateCondition"))) {
[17:29:47.771]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:47.771]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.771]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:47.771]                   if (TRUE && !signal) {
[17:29:47.771]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.771]                     {
[17:29:47.771]                       inherits <- base::inherits
[17:29:47.771]                       invokeRestart <- base::invokeRestart
[17:29:47.771]                       is.null <- base::is.null
[17:29:47.771]                       muffled <- FALSE
[17:29:47.771]                       if (inherits(cond, "message")) {
[17:29:47.771]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.771]                         if (muffled) 
[17:29:47.771]                           invokeRestart("muffleMessage")
[17:29:47.771]                       }
[17:29:47.771]                       else if (inherits(cond, "warning")) {
[17:29:47.771]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.771]                         if (muffled) 
[17:29:47.771]                           invokeRestart("muffleWarning")
[17:29:47.771]                       }
[17:29:47.771]                       else if (inherits(cond, "condition")) {
[17:29:47.771]                         if (!is.null(pattern)) {
[17:29:47.771]                           computeRestarts <- base::computeRestarts
[17:29:47.771]                           grepl <- base::grepl
[17:29:47.771]                           restarts <- computeRestarts(cond)
[17:29:47.771]                           for (restart in restarts) {
[17:29:47.771]                             name <- restart$name
[17:29:47.771]                             if (is.null(name)) 
[17:29:47.771]                               next
[17:29:47.771]                             if (!grepl(pattern, name)) 
[17:29:47.771]                               next
[17:29:47.771]                             invokeRestart(restart)
[17:29:47.771]                             muffled <- TRUE
[17:29:47.771]                             break
[17:29:47.771]                           }
[17:29:47.771]                         }
[17:29:47.771]                       }
[17:29:47.771]                       invisible(muffled)
[17:29:47.771]                     }
[17:29:47.771]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.771]                   }
[17:29:47.771]                 }
[17:29:47.771]                 else {
[17:29:47.771]                   if (TRUE) {
[17:29:47.771]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.771]                     {
[17:29:47.771]                       inherits <- base::inherits
[17:29:47.771]                       invokeRestart <- base::invokeRestart
[17:29:47.771]                       is.null <- base::is.null
[17:29:47.771]                       muffled <- FALSE
[17:29:47.771]                       if (inherits(cond, "message")) {
[17:29:47.771]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.771]                         if (muffled) 
[17:29:47.771]                           invokeRestart("muffleMessage")
[17:29:47.771]                       }
[17:29:47.771]                       else if (inherits(cond, "warning")) {
[17:29:47.771]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.771]                         if (muffled) 
[17:29:47.771]                           invokeRestart("muffleWarning")
[17:29:47.771]                       }
[17:29:47.771]                       else if (inherits(cond, "condition")) {
[17:29:47.771]                         if (!is.null(pattern)) {
[17:29:47.771]                           computeRestarts <- base::computeRestarts
[17:29:47.771]                           grepl <- base::grepl
[17:29:47.771]                           restarts <- computeRestarts(cond)
[17:29:47.771]                           for (restart in restarts) {
[17:29:47.771]                             name <- restart$name
[17:29:47.771]                             if (is.null(name)) 
[17:29:47.771]                               next
[17:29:47.771]                             if (!grepl(pattern, name)) 
[17:29:47.771]                               next
[17:29:47.771]                             invokeRestart(restart)
[17:29:47.771]                             muffled <- TRUE
[17:29:47.771]                             break
[17:29:47.771]                           }
[17:29:47.771]                         }
[17:29:47.771]                       }
[17:29:47.771]                       invisible(muffled)
[17:29:47.771]                     }
[17:29:47.771]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.771]                   }
[17:29:47.771]                 }
[17:29:47.771]             }
[17:29:47.771]         }))
[17:29:47.771]     }, error = function(ex) {
[17:29:47.771]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:47.771]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.771]                 ...future.rng), started = ...future.startTime, 
[17:29:47.771]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:47.771]             version = "1.8"), class = "FutureResult")
[17:29:47.771]     }, finally = {
[17:29:47.771]         if (!identical(...future.workdir, getwd())) 
[17:29:47.771]             setwd(...future.workdir)
[17:29:47.771]         {
[17:29:47.771]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:47.771]                 ...future.oldOptions$nwarnings <- NULL
[17:29:47.771]             }
[17:29:47.771]             base::options(...future.oldOptions)
[17:29:47.771]             if (.Platform$OS.type == "windows") {
[17:29:47.771]                 old_names <- names(...future.oldEnvVars)
[17:29:47.771]                 envs <- base::Sys.getenv()
[17:29:47.771]                 names <- names(envs)
[17:29:47.771]                 common <- intersect(names, old_names)
[17:29:47.771]                 added <- setdiff(names, old_names)
[17:29:47.771]                 removed <- setdiff(old_names, names)
[17:29:47.771]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:47.771]                   envs[common]]
[17:29:47.771]                 NAMES <- toupper(changed)
[17:29:47.771]                 args <- list()
[17:29:47.771]                 for (kk in seq_along(NAMES)) {
[17:29:47.771]                   name <- changed[[kk]]
[17:29:47.771]                   NAME <- NAMES[[kk]]
[17:29:47.771]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.771]                     next
[17:29:47.771]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.771]                 }
[17:29:47.771]                 NAMES <- toupper(added)
[17:29:47.771]                 for (kk in seq_along(NAMES)) {
[17:29:47.771]                   name <- added[[kk]]
[17:29:47.771]                   NAME <- NAMES[[kk]]
[17:29:47.771]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.771]                     next
[17:29:47.771]                   args[[name]] <- ""
[17:29:47.771]                 }
[17:29:47.771]                 NAMES <- toupper(removed)
[17:29:47.771]                 for (kk in seq_along(NAMES)) {
[17:29:47.771]                   name <- removed[[kk]]
[17:29:47.771]                   NAME <- NAMES[[kk]]
[17:29:47.771]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.771]                     next
[17:29:47.771]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.771]                 }
[17:29:47.771]                 if (length(args) > 0) 
[17:29:47.771]                   base::do.call(base::Sys.setenv, args = args)
[17:29:47.771]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:47.771]             }
[17:29:47.771]             else {
[17:29:47.771]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:47.771]             }
[17:29:47.771]             {
[17:29:47.771]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:47.771]                   0L) {
[17:29:47.771]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:47.771]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:47.771]                   base::options(opts)
[17:29:47.771]                 }
[17:29:47.771]                 {
[17:29:47.771]                   {
[17:29:47.771]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:47.771]                     NULL
[17:29:47.771]                   }
[17:29:47.771]                   options(future.plan = NULL)
[17:29:47.771]                   if (is.na(NA_character_)) 
[17:29:47.771]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.771]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:47.771]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:47.771]                     .init = FALSE)
[17:29:47.771]                 }
[17:29:47.771]             }
[17:29:47.771]         }
[17:29:47.771]     })
[17:29:47.771]     if (TRUE) {
[17:29:47.771]         base::sink(type = "output", split = FALSE)
[17:29:47.771]         if (TRUE) {
[17:29:47.771]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:47.771]         }
[17:29:47.771]         else {
[17:29:47.771]             ...future.result["stdout"] <- base::list(NULL)
[17:29:47.771]         }
[17:29:47.771]         base::close(...future.stdout)
[17:29:47.771]         ...future.stdout <- NULL
[17:29:47.771]     }
[17:29:47.771]     ...future.result$conditions <- ...future.conditions
[17:29:47.771]     ...future.result$finished <- base::Sys.time()
[17:29:47.771]     ...future.result
[17:29:47.771] }
[17:29:47.779] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:47.801] receiveMessageFromWorker() for ClusterFuture ...
[17:29:47.802] - Validating connection of MultisessionFuture
[17:29:47.802] - received message: FutureResult
[17:29:47.802] - Received FutureResult
[17:29:47.803] - Erased future from FutureRegistry
[17:29:47.803] result() for ClusterFuture ...
[17:29:47.803] - result already collected: FutureResult
[17:29:47.804] result() for ClusterFuture ... done
[17:29:47.804] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:47.804] result() for ClusterFuture ...
[17:29:47.804] - result already collected: FutureResult
[17:29:47.805] result() for ClusterFuture ... done
[17:29:47.805] result() for ClusterFuture ...
[17:29:47.805] - result already collected: FutureResult
[17:29:47.805] result() for ClusterFuture ... done
[17:29:47.807] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:47.807] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:47.808] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:47.808] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:47.809] MultisessionFuture started
[17:29:47.810] - Launch lazy future ... done
[17:29:47.810] run() for 'MultisessionFuture' ... done
[17:29:47.810] result() for ClusterFuture ...
[17:29:47.811] - result already collected: FutureResult
[17:29:47.811] result() for ClusterFuture ... done
[17:29:47.811] result() for ClusterFuture ...
[17:29:47.812] - result already collected: FutureResult
[17:29:47.812] result() for ClusterFuture ... done
[17:29:47.812] result() for ClusterFuture ...
[17:29:47.812] - result already collected: FutureResult
[17:29:47.813] result() for ClusterFuture ... done
[17:29:47.813] result() for ClusterFuture ...
[17:29:47.813] - result already collected: FutureResult
[17:29:47.813] result() for ClusterFuture ... done
[17:29:47.814] result() for ClusterFuture ...
[17:29:47.814] receiveMessageFromWorker() for ClusterFuture ...
[17:29:47.814] - Validating connection of MultisessionFuture
[17:29:47.815] - received message: FutureResult
[17:29:47.815] - Received FutureResult
[17:29:47.815] - Erased future from FutureRegistry
[17:29:47.816] result() for ClusterFuture ...
[17:29:47.816] - result already collected: FutureResult
[17:29:47.816] result() for ClusterFuture ... done
[17:29:47.816] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:47.816] result() for ClusterFuture ... done
[17:29:47.817] result() for ClusterFuture ...
[17:29:47.817] - result already collected: FutureResult
[17:29:47.817] result() for ClusterFuture ... done
[17:29:47.817] result() for ClusterFuture ...
[17:29:47.817] receiveMessageFromWorker() for ClusterFuture ...
[17:29:47.817] - Validating connection of MultisessionFuture
[17:29:47.823] - received message: FutureResult
[17:29:47.823] - Received FutureResult
[17:29:47.824] - Erased future from FutureRegistry
[17:29:47.824] result() for ClusterFuture ...
[17:29:47.824] - result already collected: FutureResult
[17:29:47.825] result() for ClusterFuture ... done
[17:29:47.825] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:47.825] result() for ClusterFuture ... done
[17:29:47.825] result() for ClusterFuture ...
[17:29:47.826] - result already collected: FutureResult
[17:29:47.826] result() for ClusterFuture ... done
[[1]]
[1] 3

[[2]]
[1] 1

[[3]]
[1] 2

[[4]]
[1] 1

[17:29:47.827] getGlobalsAndPackages() ...
[17:29:47.828] Searching for globals...
[17:29:47.830] - globals found: [3] '{', 'sample', 'x'
[17:29:47.830] Searching for globals ... DONE
[17:29:47.831] Resolving globals: FALSE
[17:29:47.831] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:47.832] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:47.833] - globals: [1] 'x'
[17:29:47.833] 
[17:29:47.833] getGlobalsAndPackages() ... DONE
[17:29:47.834] run() for 'Future' ...
[17:29:47.834] - state: 'created'
[17:29:47.835] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:47.855] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:47.855] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:47.856]   - Field: 'node'
[17:29:47.856]   - Field: 'label'
[17:29:47.856]   - Field: 'local'
[17:29:47.856]   - Field: 'owner'
[17:29:47.857]   - Field: 'envir'
[17:29:47.857]   - Field: 'workers'
[17:29:47.857]   - Field: 'packages'
[17:29:47.858]   - Field: 'gc'
[17:29:47.858]   - Field: 'conditions'
[17:29:47.858]   - Field: 'persistent'
[17:29:47.858]   - Field: 'expr'
[17:29:47.859]   - Field: 'uuid'
[17:29:47.859]   - Field: 'seed'
[17:29:47.859]   - Field: 'version'
[17:29:47.860]   - Field: 'result'
[17:29:47.860]   - Field: 'asynchronous'
[17:29:47.860]   - Field: 'calls'
[17:29:47.860]   - Field: 'globals'
[17:29:47.861]   - Field: 'stdout'
[17:29:47.861]   - Field: 'earlySignal'
[17:29:47.861]   - Field: 'lazy'
[17:29:47.862]   - Field: 'state'
[17:29:47.862] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:47.862] - Launch lazy future ...
[17:29:47.863] Packages needed by the future expression (n = 0): <none>
[17:29:47.863] Packages needed by future strategies (n = 0): <none>
[17:29:47.864] {
[17:29:47.864]     {
[17:29:47.864]         {
[17:29:47.864]             ...future.startTime <- base::Sys.time()
[17:29:47.864]             {
[17:29:47.864]                 {
[17:29:47.864]                   {
[17:29:47.864]                     {
[17:29:47.864]                       base::local({
[17:29:47.864]                         has_future <- base::requireNamespace("future", 
[17:29:47.864]                           quietly = TRUE)
[17:29:47.864]                         if (has_future) {
[17:29:47.864]                           ns <- base::getNamespace("future")
[17:29:47.864]                           version <- ns[[".package"]][["version"]]
[17:29:47.864]                           if (is.null(version)) 
[17:29:47.864]                             version <- utils::packageVersion("future")
[17:29:47.864]                         }
[17:29:47.864]                         else {
[17:29:47.864]                           version <- NULL
[17:29:47.864]                         }
[17:29:47.864]                         if (!has_future || version < "1.8.0") {
[17:29:47.864]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:47.864]                             "", base::R.version$version.string), 
[17:29:47.864]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:47.864]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:47.864]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:47.864]                               "release", "version")], collapse = " "), 
[17:29:47.864]                             hostname = base::Sys.info()[["nodename"]])
[17:29:47.864]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:47.864]                             info)
[17:29:47.864]                           info <- base::paste(info, collapse = "; ")
[17:29:47.864]                           if (!has_future) {
[17:29:47.864]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:47.864]                               info)
[17:29:47.864]                           }
[17:29:47.864]                           else {
[17:29:47.864]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:47.864]                               info, version)
[17:29:47.864]                           }
[17:29:47.864]                           base::stop(msg)
[17:29:47.864]                         }
[17:29:47.864]                       })
[17:29:47.864]                     }
[17:29:47.864]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:47.864]                     base::options(mc.cores = 1L)
[17:29:47.864]                   }
[17:29:47.864]                   ...future.strategy.old <- future::plan("list")
[17:29:47.864]                   options(future.plan = NULL)
[17:29:47.864]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.864]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:47.864]                 }
[17:29:47.864]                 ...future.workdir <- getwd()
[17:29:47.864]             }
[17:29:47.864]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:47.864]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:47.864]         }
[17:29:47.864]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:47.864]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:47.864]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:47.864]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:47.864]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:47.864]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:47.864]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:47.864]             base::names(...future.oldOptions))
[17:29:47.864]     }
[17:29:47.864]     if (FALSE) {
[17:29:47.864]     }
[17:29:47.864]     else {
[17:29:47.864]         if (TRUE) {
[17:29:47.864]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:47.864]                 open = "w")
[17:29:47.864]         }
[17:29:47.864]         else {
[17:29:47.864]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:47.864]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:47.864]         }
[17:29:47.864]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:47.864]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:47.864]             base::sink(type = "output", split = FALSE)
[17:29:47.864]             base::close(...future.stdout)
[17:29:47.864]         }, add = TRUE)
[17:29:47.864]     }
[17:29:47.864]     ...future.frame <- base::sys.nframe()
[17:29:47.864]     ...future.conditions <- base::list()
[17:29:47.864]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:47.864]     if (FALSE) {
[17:29:47.864]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:47.864]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:47.864]     }
[17:29:47.864]     ...future.result <- base::tryCatch({
[17:29:47.864]         base::withCallingHandlers({
[17:29:47.864]             ...future.value <- base::withVisible(base::local({
[17:29:47.864]                 ...future.makeSendCondition <- base::local({
[17:29:47.864]                   sendCondition <- NULL
[17:29:47.864]                   function(frame = 1L) {
[17:29:47.864]                     if (is.function(sendCondition)) 
[17:29:47.864]                       return(sendCondition)
[17:29:47.864]                     ns <- getNamespace("parallel")
[17:29:47.864]                     if (exists("sendData", mode = "function", 
[17:29:47.864]                       envir = ns)) {
[17:29:47.864]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:47.864]                         envir = ns)
[17:29:47.864]                       envir <- sys.frame(frame)
[17:29:47.864]                       master <- NULL
[17:29:47.864]                       while (!identical(envir, .GlobalEnv) && 
[17:29:47.864]                         !identical(envir, emptyenv())) {
[17:29:47.864]                         if (exists("master", mode = "list", envir = envir, 
[17:29:47.864]                           inherits = FALSE)) {
[17:29:47.864]                           master <- get("master", mode = "list", 
[17:29:47.864]                             envir = envir, inherits = FALSE)
[17:29:47.864]                           if (inherits(master, c("SOCKnode", 
[17:29:47.864]                             "SOCK0node"))) {
[17:29:47.864]                             sendCondition <<- function(cond) {
[17:29:47.864]                               data <- list(type = "VALUE", value = cond, 
[17:29:47.864]                                 success = TRUE)
[17:29:47.864]                               parallel_sendData(master, data)
[17:29:47.864]                             }
[17:29:47.864]                             return(sendCondition)
[17:29:47.864]                           }
[17:29:47.864]                         }
[17:29:47.864]                         frame <- frame + 1L
[17:29:47.864]                         envir <- sys.frame(frame)
[17:29:47.864]                       }
[17:29:47.864]                     }
[17:29:47.864]                     sendCondition <<- function(cond) NULL
[17:29:47.864]                   }
[17:29:47.864]                 })
[17:29:47.864]                 withCallingHandlers({
[17:29:47.864]                   {
[17:29:47.864]                     sample(x, size = 1L)
[17:29:47.864]                   }
[17:29:47.864]                 }, immediateCondition = function(cond) {
[17:29:47.864]                   sendCondition <- ...future.makeSendCondition()
[17:29:47.864]                   sendCondition(cond)
[17:29:47.864]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.864]                   {
[17:29:47.864]                     inherits <- base::inherits
[17:29:47.864]                     invokeRestart <- base::invokeRestart
[17:29:47.864]                     is.null <- base::is.null
[17:29:47.864]                     muffled <- FALSE
[17:29:47.864]                     if (inherits(cond, "message")) {
[17:29:47.864]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:47.864]                       if (muffled) 
[17:29:47.864]                         invokeRestart("muffleMessage")
[17:29:47.864]                     }
[17:29:47.864]                     else if (inherits(cond, "warning")) {
[17:29:47.864]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:47.864]                       if (muffled) 
[17:29:47.864]                         invokeRestart("muffleWarning")
[17:29:47.864]                     }
[17:29:47.864]                     else if (inherits(cond, "condition")) {
[17:29:47.864]                       if (!is.null(pattern)) {
[17:29:47.864]                         computeRestarts <- base::computeRestarts
[17:29:47.864]                         grepl <- base::grepl
[17:29:47.864]                         restarts <- computeRestarts(cond)
[17:29:47.864]                         for (restart in restarts) {
[17:29:47.864]                           name <- restart$name
[17:29:47.864]                           if (is.null(name)) 
[17:29:47.864]                             next
[17:29:47.864]                           if (!grepl(pattern, name)) 
[17:29:47.864]                             next
[17:29:47.864]                           invokeRestart(restart)
[17:29:47.864]                           muffled <- TRUE
[17:29:47.864]                           break
[17:29:47.864]                         }
[17:29:47.864]                       }
[17:29:47.864]                     }
[17:29:47.864]                     invisible(muffled)
[17:29:47.864]                   }
[17:29:47.864]                   muffleCondition(cond)
[17:29:47.864]                 })
[17:29:47.864]             }))
[17:29:47.864]             future::FutureResult(value = ...future.value$value, 
[17:29:47.864]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.864]                   ...future.rng), globalenv = if (FALSE) 
[17:29:47.864]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:47.864]                     ...future.globalenv.names))
[17:29:47.864]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:47.864]         }, condition = base::local({
[17:29:47.864]             c <- base::c
[17:29:47.864]             inherits <- base::inherits
[17:29:47.864]             invokeRestart <- base::invokeRestart
[17:29:47.864]             length <- base::length
[17:29:47.864]             list <- base::list
[17:29:47.864]             seq.int <- base::seq.int
[17:29:47.864]             signalCondition <- base::signalCondition
[17:29:47.864]             sys.calls <- base::sys.calls
[17:29:47.864]             `[[` <- base::`[[`
[17:29:47.864]             `+` <- base::`+`
[17:29:47.864]             `<<-` <- base::`<<-`
[17:29:47.864]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:47.864]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:47.864]                   3L)]
[17:29:47.864]             }
[17:29:47.864]             function(cond) {
[17:29:47.864]                 is_error <- inherits(cond, "error")
[17:29:47.864]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:47.864]                   NULL)
[17:29:47.864]                 if (is_error) {
[17:29:47.864]                   sessionInformation <- function() {
[17:29:47.864]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:47.864]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:47.864]                       search = base::search(), system = base::Sys.info())
[17:29:47.864]                   }
[17:29:47.864]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.864]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:47.864]                     cond$call), session = sessionInformation(), 
[17:29:47.864]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:47.864]                   signalCondition(cond)
[17:29:47.864]                 }
[17:29:47.864]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:47.864]                 "immediateCondition"))) {
[17:29:47.864]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:47.864]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.864]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:47.864]                   if (TRUE && !signal) {
[17:29:47.864]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.864]                     {
[17:29:47.864]                       inherits <- base::inherits
[17:29:47.864]                       invokeRestart <- base::invokeRestart
[17:29:47.864]                       is.null <- base::is.null
[17:29:47.864]                       muffled <- FALSE
[17:29:47.864]                       if (inherits(cond, "message")) {
[17:29:47.864]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.864]                         if (muffled) 
[17:29:47.864]                           invokeRestart("muffleMessage")
[17:29:47.864]                       }
[17:29:47.864]                       else if (inherits(cond, "warning")) {
[17:29:47.864]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.864]                         if (muffled) 
[17:29:47.864]                           invokeRestart("muffleWarning")
[17:29:47.864]                       }
[17:29:47.864]                       else if (inherits(cond, "condition")) {
[17:29:47.864]                         if (!is.null(pattern)) {
[17:29:47.864]                           computeRestarts <- base::computeRestarts
[17:29:47.864]                           grepl <- base::grepl
[17:29:47.864]                           restarts <- computeRestarts(cond)
[17:29:47.864]                           for (restart in restarts) {
[17:29:47.864]                             name <- restart$name
[17:29:47.864]                             if (is.null(name)) 
[17:29:47.864]                               next
[17:29:47.864]                             if (!grepl(pattern, name)) 
[17:29:47.864]                               next
[17:29:47.864]                             invokeRestart(restart)
[17:29:47.864]                             muffled <- TRUE
[17:29:47.864]                             break
[17:29:47.864]                           }
[17:29:47.864]                         }
[17:29:47.864]                       }
[17:29:47.864]                       invisible(muffled)
[17:29:47.864]                     }
[17:29:47.864]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.864]                   }
[17:29:47.864]                 }
[17:29:47.864]                 else {
[17:29:47.864]                   if (TRUE) {
[17:29:47.864]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.864]                     {
[17:29:47.864]                       inherits <- base::inherits
[17:29:47.864]                       invokeRestart <- base::invokeRestart
[17:29:47.864]                       is.null <- base::is.null
[17:29:47.864]                       muffled <- FALSE
[17:29:47.864]                       if (inherits(cond, "message")) {
[17:29:47.864]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.864]                         if (muffled) 
[17:29:47.864]                           invokeRestart("muffleMessage")
[17:29:47.864]                       }
[17:29:47.864]                       else if (inherits(cond, "warning")) {
[17:29:47.864]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.864]                         if (muffled) 
[17:29:47.864]                           invokeRestart("muffleWarning")
[17:29:47.864]                       }
[17:29:47.864]                       else if (inherits(cond, "condition")) {
[17:29:47.864]                         if (!is.null(pattern)) {
[17:29:47.864]                           computeRestarts <- base::computeRestarts
[17:29:47.864]                           grepl <- base::grepl
[17:29:47.864]                           restarts <- computeRestarts(cond)
[17:29:47.864]                           for (restart in restarts) {
[17:29:47.864]                             name <- restart$name
[17:29:47.864]                             if (is.null(name)) 
[17:29:47.864]                               next
[17:29:47.864]                             if (!grepl(pattern, name)) 
[17:29:47.864]                               next
[17:29:47.864]                             invokeRestart(restart)
[17:29:47.864]                             muffled <- TRUE
[17:29:47.864]                             break
[17:29:47.864]                           }
[17:29:47.864]                         }
[17:29:47.864]                       }
[17:29:47.864]                       invisible(muffled)
[17:29:47.864]                     }
[17:29:47.864]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.864]                   }
[17:29:47.864]                 }
[17:29:47.864]             }
[17:29:47.864]         }))
[17:29:47.864]     }, error = function(ex) {
[17:29:47.864]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:47.864]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.864]                 ...future.rng), started = ...future.startTime, 
[17:29:47.864]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:47.864]             version = "1.8"), class = "FutureResult")
[17:29:47.864]     }, finally = {
[17:29:47.864]         if (!identical(...future.workdir, getwd())) 
[17:29:47.864]             setwd(...future.workdir)
[17:29:47.864]         {
[17:29:47.864]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:47.864]                 ...future.oldOptions$nwarnings <- NULL
[17:29:47.864]             }
[17:29:47.864]             base::options(...future.oldOptions)
[17:29:47.864]             if (.Platform$OS.type == "windows") {
[17:29:47.864]                 old_names <- names(...future.oldEnvVars)
[17:29:47.864]                 envs <- base::Sys.getenv()
[17:29:47.864]                 names <- names(envs)
[17:29:47.864]                 common <- intersect(names, old_names)
[17:29:47.864]                 added <- setdiff(names, old_names)
[17:29:47.864]                 removed <- setdiff(old_names, names)
[17:29:47.864]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:47.864]                   envs[common]]
[17:29:47.864]                 NAMES <- toupper(changed)
[17:29:47.864]                 args <- list()
[17:29:47.864]                 for (kk in seq_along(NAMES)) {
[17:29:47.864]                   name <- changed[[kk]]
[17:29:47.864]                   NAME <- NAMES[[kk]]
[17:29:47.864]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.864]                     next
[17:29:47.864]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.864]                 }
[17:29:47.864]                 NAMES <- toupper(added)
[17:29:47.864]                 for (kk in seq_along(NAMES)) {
[17:29:47.864]                   name <- added[[kk]]
[17:29:47.864]                   NAME <- NAMES[[kk]]
[17:29:47.864]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.864]                     next
[17:29:47.864]                   args[[name]] <- ""
[17:29:47.864]                 }
[17:29:47.864]                 NAMES <- toupper(removed)
[17:29:47.864]                 for (kk in seq_along(NAMES)) {
[17:29:47.864]                   name <- removed[[kk]]
[17:29:47.864]                   NAME <- NAMES[[kk]]
[17:29:47.864]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.864]                     next
[17:29:47.864]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.864]                 }
[17:29:47.864]                 if (length(args) > 0) 
[17:29:47.864]                   base::do.call(base::Sys.setenv, args = args)
[17:29:47.864]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:47.864]             }
[17:29:47.864]             else {
[17:29:47.864]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:47.864]             }
[17:29:47.864]             {
[17:29:47.864]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:47.864]                   0L) {
[17:29:47.864]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:47.864]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:47.864]                   base::options(opts)
[17:29:47.864]                 }
[17:29:47.864]                 {
[17:29:47.864]                   {
[17:29:47.864]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:47.864]                     NULL
[17:29:47.864]                   }
[17:29:47.864]                   options(future.plan = NULL)
[17:29:47.864]                   if (is.na(NA_character_)) 
[17:29:47.864]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.864]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:47.864]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:47.864]                     .init = FALSE)
[17:29:47.864]                 }
[17:29:47.864]             }
[17:29:47.864]         }
[17:29:47.864]     })
[17:29:47.864]     if (TRUE) {
[17:29:47.864]         base::sink(type = "output", split = FALSE)
[17:29:47.864]         if (TRUE) {
[17:29:47.864]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:47.864]         }
[17:29:47.864]         else {
[17:29:47.864]             ...future.result["stdout"] <- base::list(NULL)
[17:29:47.864]         }
[17:29:47.864]         base::close(...future.stdout)
[17:29:47.864]         ...future.stdout <- NULL
[17:29:47.864]     }
[17:29:47.864]     ...future.result$conditions <- ...future.conditions
[17:29:47.864]     ...future.result$finished <- base::Sys.time()
[17:29:47.864]     ...future.result
[17:29:47.864] }
[17:29:47.870] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:47.870] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:47.870] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:47.870] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:47.871] MultisessionFuture started
[17:29:47.871] - Launch lazy future ... done
[17:29:47.872] run() for 'MultisessionFuture' ... done
[17:29:47.873] getGlobalsAndPackages() ...
[17:29:47.873] Searching for globals...
[17:29:47.875] - globals found: [3] '{', 'sample', 'x'
[17:29:47.876] Searching for globals ... DONE
[17:29:47.876] Resolving globals: FALSE
[17:29:47.877] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:47.877] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:47.878] - globals: [1] 'x'
[17:29:47.878] 
[17:29:47.878] getGlobalsAndPackages() ... DONE
[17:29:47.879] run() for 'Future' ...
[17:29:47.879] - state: 'created'
[17:29:47.879] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:47.901] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:47.902] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:47.902]   - Field: 'node'
[17:29:47.902]   - Field: 'label'
[17:29:47.902]   - Field: 'local'
[17:29:47.902]   - Field: 'owner'
[17:29:47.903]   - Field: 'envir'
[17:29:47.903]   - Field: 'workers'
[17:29:47.903]   - Field: 'packages'
[17:29:47.903]   - Field: 'gc'
[17:29:47.903]   - Field: 'conditions'
[17:29:47.903]   - Field: 'persistent'
[17:29:47.904]   - Field: 'expr'
[17:29:47.904]   - Field: 'uuid'
[17:29:47.904]   - Field: 'seed'
[17:29:47.904]   - Field: 'version'
[17:29:47.904]   - Field: 'result'
[17:29:47.904]   - Field: 'asynchronous'
[17:29:47.905]   - Field: 'calls'
[17:29:47.905]   - Field: 'globals'
[17:29:47.905]   - Field: 'stdout'
[17:29:47.905]   - Field: 'earlySignal'
[17:29:47.905]   - Field: 'lazy'
[17:29:47.906]   - Field: 'state'
[17:29:47.906] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:47.906] - Launch lazy future ...
[17:29:47.906] Packages needed by the future expression (n = 0): <none>
[17:29:47.907] Packages needed by future strategies (n = 0): <none>
[17:29:47.907] {
[17:29:47.907]     {
[17:29:47.907]         {
[17:29:47.907]             ...future.startTime <- base::Sys.time()
[17:29:47.907]             {
[17:29:47.907]                 {
[17:29:47.907]                   {
[17:29:47.907]                     {
[17:29:47.907]                       base::local({
[17:29:47.907]                         has_future <- base::requireNamespace("future", 
[17:29:47.907]                           quietly = TRUE)
[17:29:47.907]                         if (has_future) {
[17:29:47.907]                           ns <- base::getNamespace("future")
[17:29:47.907]                           version <- ns[[".package"]][["version"]]
[17:29:47.907]                           if (is.null(version)) 
[17:29:47.907]                             version <- utils::packageVersion("future")
[17:29:47.907]                         }
[17:29:47.907]                         else {
[17:29:47.907]                           version <- NULL
[17:29:47.907]                         }
[17:29:47.907]                         if (!has_future || version < "1.8.0") {
[17:29:47.907]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:47.907]                             "", base::R.version$version.string), 
[17:29:47.907]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:47.907]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:47.907]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:47.907]                               "release", "version")], collapse = " "), 
[17:29:47.907]                             hostname = base::Sys.info()[["nodename"]])
[17:29:47.907]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:47.907]                             info)
[17:29:47.907]                           info <- base::paste(info, collapse = "; ")
[17:29:47.907]                           if (!has_future) {
[17:29:47.907]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:47.907]                               info)
[17:29:47.907]                           }
[17:29:47.907]                           else {
[17:29:47.907]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:47.907]                               info, version)
[17:29:47.907]                           }
[17:29:47.907]                           base::stop(msg)
[17:29:47.907]                         }
[17:29:47.907]                       })
[17:29:47.907]                     }
[17:29:47.907]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:47.907]                     base::options(mc.cores = 1L)
[17:29:47.907]                   }
[17:29:47.907]                   ...future.strategy.old <- future::plan("list")
[17:29:47.907]                   options(future.plan = NULL)
[17:29:47.907]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.907]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:47.907]                 }
[17:29:47.907]                 ...future.workdir <- getwd()
[17:29:47.907]             }
[17:29:47.907]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:47.907]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:47.907]         }
[17:29:47.907]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:47.907]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:47.907]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:47.907]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:47.907]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:47.907]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:47.907]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:47.907]             base::names(...future.oldOptions))
[17:29:47.907]     }
[17:29:47.907]     if (FALSE) {
[17:29:47.907]     }
[17:29:47.907]     else {
[17:29:47.907]         if (TRUE) {
[17:29:47.907]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:47.907]                 open = "w")
[17:29:47.907]         }
[17:29:47.907]         else {
[17:29:47.907]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:47.907]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:47.907]         }
[17:29:47.907]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:47.907]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:47.907]             base::sink(type = "output", split = FALSE)
[17:29:47.907]             base::close(...future.stdout)
[17:29:47.907]         }, add = TRUE)
[17:29:47.907]     }
[17:29:47.907]     ...future.frame <- base::sys.nframe()
[17:29:47.907]     ...future.conditions <- base::list()
[17:29:47.907]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:47.907]     if (FALSE) {
[17:29:47.907]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:47.907]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:47.907]     }
[17:29:47.907]     ...future.result <- base::tryCatch({
[17:29:47.907]         base::withCallingHandlers({
[17:29:47.907]             ...future.value <- base::withVisible(base::local({
[17:29:47.907]                 ...future.makeSendCondition <- base::local({
[17:29:47.907]                   sendCondition <- NULL
[17:29:47.907]                   function(frame = 1L) {
[17:29:47.907]                     if (is.function(sendCondition)) 
[17:29:47.907]                       return(sendCondition)
[17:29:47.907]                     ns <- getNamespace("parallel")
[17:29:47.907]                     if (exists("sendData", mode = "function", 
[17:29:47.907]                       envir = ns)) {
[17:29:47.907]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:47.907]                         envir = ns)
[17:29:47.907]                       envir <- sys.frame(frame)
[17:29:47.907]                       master <- NULL
[17:29:47.907]                       while (!identical(envir, .GlobalEnv) && 
[17:29:47.907]                         !identical(envir, emptyenv())) {
[17:29:47.907]                         if (exists("master", mode = "list", envir = envir, 
[17:29:47.907]                           inherits = FALSE)) {
[17:29:47.907]                           master <- get("master", mode = "list", 
[17:29:47.907]                             envir = envir, inherits = FALSE)
[17:29:47.907]                           if (inherits(master, c("SOCKnode", 
[17:29:47.907]                             "SOCK0node"))) {
[17:29:47.907]                             sendCondition <<- function(cond) {
[17:29:47.907]                               data <- list(type = "VALUE", value = cond, 
[17:29:47.907]                                 success = TRUE)
[17:29:47.907]                               parallel_sendData(master, data)
[17:29:47.907]                             }
[17:29:47.907]                             return(sendCondition)
[17:29:47.907]                           }
[17:29:47.907]                         }
[17:29:47.907]                         frame <- frame + 1L
[17:29:47.907]                         envir <- sys.frame(frame)
[17:29:47.907]                       }
[17:29:47.907]                     }
[17:29:47.907]                     sendCondition <<- function(cond) NULL
[17:29:47.907]                   }
[17:29:47.907]                 })
[17:29:47.907]                 withCallingHandlers({
[17:29:47.907]                   {
[17:29:47.907]                     sample(x, size = 1L)
[17:29:47.907]                   }
[17:29:47.907]                 }, immediateCondition = function(cond) {
[17:29:47.907]                   sendCondition <- ...future.makeSendCondition()
[17:29:47.907]                   sendCondition(cond)
[17:29:47.907]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.907]                   {
[17:29:47.907]                     inherits <- base::inherits
[17:29:47.907]                     invokeRestart <- base::invokeRestart
[17:29:47.907]                     is.null <- base::is.null
[17:29:47.907]                     muffled <- FALSE
[17:29:47.907]                     if (inherits(cond, "message")) {
[17:29:47.907]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:47.907]                       if (muffled) 
[17:29:47.907]                         invokeRestart("muffleMessage")
[17:29:47.907]                     }
[17:29:47.907]                     else if (inherits(cond, "warning")) {
[17:29:47.907]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:47.907]                       if (muffled) 
[17:29:47.907]                         invokeRestart("muffleWarning")
[17:29:47.907]                     }
[17:29:47.907]                     else if (inherits(cond, "condition")) {
[17:29:47.907]                       if (!is.null(pattern)) {
[17:29:47.907]                         computeRestarts <- base::computeRestarts
[17:29:47.907]                         grepl <- base::grepl
[17:29:47.907]                         restarts <- computeRestarts(cond)
[17:29:47.907]                         for (restart in restarts) {
[17:29:47.907]                           name <- restart$name
[17:29:47.907]                           if (is.null(name)) 
[17:29:47.907]                             next
[17:29:47.907]                           if (!grepl(pattern, name)) 
[17:29:47.907]                             next
[17:29:47.907]                           invokeRestart(restart)
[17:29:47.907]                           muffled <- TRUE
[17:29:47.907]                           break
[17:29:47.907]                         }
[17:29:47.907]                       }
[17:29:47.907]                     }
[17:29:47.907]                     invisible(muffled)
[17:29:47.907]                   }
[17:29:47.907]                   muffleCondition(cond)
[17:29:47.907]                 })
[17:29:47.907]             }))
[17:29:47.907]             future::FutureResult(value = ...future.value$value, 
[17:29:47.907]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.907]                   ...future.rng), globalenv = if (FALSE) 
[17:29:47.907]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:47.907]                     ...future.globalenv.names))
[17:29:47.907]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:47.907]         }, condition = base::local({
[17:29:47.907]             c <- base::c
[17:29:47.907]             inherits <- base::inherits
[17:29:47.907]             invokeRestart <- base::invokeRestart
[17:29:47.907]             length <- base::length
[17:29:47.907]             list <- base::list
[17:29:47.907]             seq.int <- base::seq.int
[17:29:47.907]             signalCondition <- base::signalCondition
[17:29:47.907]             sys.calls <- base::sys.calls
[17:29:47.907]             `[[` <- base::`[[`
[17:29:47.907]             `+` <- base::`+`
[17:29:47.907]             `<<-` <- base::`<<-`
[17:29:47.907]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:47.907]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:47.907]                   3L)]
[17:29:47.907]             }
[17:29:47.907]             function(cond) {
[17:29:47.907]                 is_error <- inherits(cond, "error")
[17:29:47.907]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:47.907]                   NULL)
[17:29:47.907]                 if (is_error) {
[17:29:47.907]                   sessionInformation <- function() {
[17:29:47.907]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:47.907]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:47.907]                       search = base::search(), system = base::Sys.info())
[17:29:47.907]                   }
[17:29:47.907]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.907]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:47.907]                     cond$call), session = sessionInformation(), 
[17:29:47.907]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:47.907]                   signalCondition(cond)
[17:29:47.907]                 }
[17:29:47.907]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:47.907]                 "immediateCondition"))) {
[17:29:47.907]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:47.907]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.907]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:47.907]                   if (TRUE && !signal) {
[17:29:47.907]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.907]                     {
[17:29:47.907]                       inherits <- base::inherits
[17:29:47.907]                       invokeRestart <- base::invokeRestart
[17:29:47.907]                       is.null <- base::is.null
[17:29:47.907]                       muffled <- FALSE
[17:29:47.907]                       if (inherits(cond, "message")) {
[17:29:47.907]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.907]                         if (muffled) 
[17:29:47.907]                           invokeRestart("muffleMessage")
[17:29:47.907]                       }
[17:29:47.907]                       else if (inherits(cond, "warning")) {
[17:29:47.907]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.907]                         if (muffled) 
[17:29:47.907]                           invokeRestart("muffleWarning")
[17:29:47.907]                       }
[17:29:47.907]                       else if (inherits(cond, "condition")) {
[17:29:47.907]                         if (!is.null(pattern)) {
[17:29:47.907]                           computeRestarts <- base::computeRestarts
[17:29:47.907]                           grepl <- base::grepl
[17:29:47.907]                           restarts <- computeRestarts(cond)
[17:29:47.907]                           for (restart in restarts) {
[17:29:47.907]                             name <- restart$name
[17:29:47.907]                             if (is.null(name)) 
[17:29:47.907]                               next
[17:29:47.907]                             if (!grepl(pattern, name)) 
[17:29:47.907]                               next
[17:29:47.907]                             invokeRestart(restart)
[17:29:47.907]                             muffled <- TRUE
[17:29:47.907]                             break
[17:29:47.907]                           }
[17:29:47.907]                         }
[17:29:47.907]                       }
[17:29:47.907]                       invisible(muffled)
[17:29:47.907]                     }
[17:29:47.907]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.907]                   }
[17:29:47.907]                 }
[17:29:47.907]                 else {
[17:29:47.907]                   if (TRUE) {
[17:29:47.907]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.907]                     {
[17:29:47.907]                       inherits <- base::inherits
[17:29:47.907]                       invokeRestart <- base::invokeRestart
[17:29:47.907]                       is.null <- base::is.null
[17:29:47.907]                       muffled <- FALSE
[17:29:47.907]                       if (inherits(cond, "message")) {
[17:29:47.907]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.907]                         if (muffled) 
[17:29:47.907]                           invokeRestart("muffleMessage")
[17:29:47.907]                       }
[17:29:47.907]                       else if (inherits(cond, "warning")) {
[17:29:47.907]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.907]                         if (muffled) 
[17:29:47.907]                           invokeRestart("muffleWarning")
[17:29:47.907]                       }
[17:29:47.907]                       else if (inherits(cond, "condition")) {
[17:29:47.907]                         if (!is.null(pattern)) {
[17:29:47.907]                           computeRestarts <- base::computeRestarts
[17:29:47.907]                           grepl <- base::grepl
[17:29:47.907]                           restarts <- computeRestarts(cond)
[17:29:47.907]                           for (restart in restarts) {
[17:29:47.907]                             name <- restart$name
[17:29:47.907]                             if (is.null(name)) 
[17:29:47.907]                               next
[17:29:47.907]                             if (!grepl(pattern, name)) 
[17:29:47.907]                               next
[17:29:47.907]                             invokeRestart(restart)
[17:29:47.907]                             muffled <- TRUE
[17:29:47.907]                             break
[17:29:47.907]                           }
[17:29:47.907]                         }
[17:29:47.907]                       }
[17:29:47.907]                       invisible(muffled)
[17:29:47.907]                     }
[17:29:47.907]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.907]                   }
[17:29:47.907]                 }
[17:29:47.907]             }
[17:29:47.907]         }))
[17:29:47.907]     }, error = function(ex) {
[17:29:47.907]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:47.907]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.907]                 ...future.rng), started = ...future.startTime, 
[17:29:47.907]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:47.907]             version = "1.8"), class = "FutureResult")
[17:29:47.907]     }, finally = {
[17:29:47.907]         if (!identical(...future.workdir, getwd())) 
[17:29:47.907]             setwd(...future.workdir)
[17:29:47.907]         {
[17:29:47.907]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:47.907]                 ...future.oldOptions$nwarnings <- NULL
[17:29:47.907]             }
[17:29:47.907]             base::options(...future.oldOptions)
[17:29:47.907]             if (.Platform$OS.type == "windows") {
[17:29:47.907]                 old_names <- names(...future.oldEnvVars)
[17:29:47.907]                 envs <- base::Sys.getenv()
[17:29:47.907]                 names <- names(envs)
[17:29:47.907]                 common <- intersect(names, old_names)
[17:29:47.907]                 added <- setdiff(names, old_names)
[17:29:47.907]                 removed <- setdiff(old_names, names)
[17:29:47.907]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:47.907]                   envs[common]]
[17:29:47.907]                 NAMES <- toupper(changed)
[17:29:47.907]                 args <- list()
[17:29:47.907]                 for (kk in seq_along(NAMES)) {
[17:29:47.907]                   name <- changed[[kk]]
[17:29:47.907]                   NAME <- NAMES[[kk]]
[17:29:47.907]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.907]                     next
[17:29:47.907]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.907]                 }
[17:29:47.907]                 NAMES <- toupper(added)
[17:29:47.907]                 for (kk in seq_along(NAMES)) {
[17:29:47.907]                   name <- added[[kk]]
[17:29:47.907]                   NAME <- NAMES[[kk]]
[17:29:47.907]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.907]                     next
[17:29:47.907]                   args[[name]] <- ""
[17:29:47.907]                 }
[17:29:47.907]                 NAMES <- toupper(removed)
[17:29:47.907]                 for (kk in seq_along(NAMES)) {
[17:29:47.907]                   name <- removed[[kk]]
[17:29:47.907]                   NAME <- NAMES[[kk]]
[17:29:47.907]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.907]                     next
[17:29:47.907]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.907]                 }
[17:29:47.907]                 if (length(args) > 0) 
[17:29:47.907]                   base::do.call(base::Sys.setenv, args = args)
[17:29:47.907]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:47.907]             }
[17:29:47.907]             else {
[17:29:47.907]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:47.907]             }
[17:29:47.907]             {
[17:29:47.907]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:47.907]                   0L) {
[17:29:47.907]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:47.907]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:47.907]                   base::options(opts)
[17:29:47.907]                 }
[17:29:47.907]                 {
[17:29:47.907]                   {
[17:29:47.907]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:47.907]                     NULL
[17:29:47.907]                   }
[17:29:47.907]                   options(future.plan = NULL)
[17:29:47.907]                   if (is.na(NA_character_)) 
[17:29:47.907]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.907]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:47.907]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:47.907]                     .init = FALSE)
[17:29:47.907]                 }
[17:29:47.907]             }
[17:29:47.907]         }
[17:29:47.907]     })
[17:29:47.907]     if (TRUE) {
[17:29:47.907]         base::sink(type = "output", split = FALSE)
[17:29:47.907]         if (TRUE) {
[17:29:47.907]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:47.907]         }
[17:29:47.907]         else {
[17:29:47.907]             ...future.result["stdout"] <- base::list(NULL)
[17:29:47.907]         }
[17:29:47.907]         base::close(...future.stdout)
[17:29:47.907]         ...future.stdout <- NULL
[17:29:47.907]     }
[17:29:47.907]     ...future.result$conditions <- ...future.conditions
[17:29:47.907]     ...future.result$finished <- base::Sys.time()
[17:29:47.907]     ...future.result
[17:29:47.907] }
[17:29:47.914] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:47.915] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:47.915] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:47.915] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:47.916] MultisessionFuture started
[17:29:47.916] - Launch lazy future ... done
[17:29:47.916] run() for 'MultisessionFuture' ... done
[17:29:47.922] getGlobalsAndPackages() ...
[17:29:47.922] Searching for globals...
[17:29:47.924] - globals found: [3] '{', 'sample', 'x'
[17:29:47.925] Searching for globals ... DONE
[17:29:47.925] Resolving globals: FALSE
[17:29:47.926] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:47.926] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:47.927] - globals: [1] 'x'
[17:29:47.927] 
[17:29:47.927] getGlobalsAndPackages() ... DONE
[17:29:47.927] run() for 'Future' ...
[17:29:47.928] - state: 'created'
[17:29:47.928] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:47.946] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:47.947] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:47.947]   - Field: 'node'
[17:29:47.948]   - Field: 'label'
[17:29:47.948]   - Field: 'local'
[17:29:47.948]   - Field: 'owner'
[17:29:47.949]   - Field: 'envir'
[17:29:47.949]   - Field: 'workers'
[17:29:47.949]   - Field: 'packages'
[17:29:47.950]   - Field: 'gc'
[17:29:47.950]   - Field: 'conditions'
[17:29:47.950]   - Field: 'persistent'
[17:29:47.951]   - Field: 'expr'
[17:29:47.951]   - Field: 'uuid'
[17:29:47.951]   - Field: 'seed'
[17:29:47.952]   - Field: 'version'
[17:29:47.952]   - Field: 'result'
[17:29:47.952]   - Field: 'asynchronous'
[17:29:47.953]   - Field: 'calls'
[17:29:47.953]   - Field: 'globals'
[17:29:47.953]   - Field: 'stdout'
[17:29:47.953]   - Field: 'earlySignal'
[17:29:47.954]   - Field: 'lazy'
[17:29:47.954]   - Field: 'state'
[17:29:47.954] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:47.955] - Launch lazy future ...
[17:29:47.955] Packages needed by the future expression (n = 0): <none>
[17:29:47.956] Packages needed by future strategies (n = 0): <none>
[17:29:47.957] {
[17:29:47.957]     {
[17:29:47.957]         {
[17:29:47.957]             ...future.startTime <- base::Sys.time()
[17:29:47.957]             {
[17:29:47.957]                 {
[17:29:47.957]                   {
[17:29:47.957]                     {
[17:29:47.957]                       base::local({
[17:29:47.957]                         has_future <- base::requireNamespace("future", 
[17:29:47.957]                           quietly = TRUE)
[17:29:47.957]                         if (has_future) {
[17:29:47.957]                           ns <- base::getNamespace("future")
[17:29:47.957]                           version <- ns[[".package"]][["version"]]
[17:29:47.957]                           if (is.null(version)) 
[17:29:47.957]                             version <- utils::packageVersion("future")
[17:29:47.957]                         }
[17:29:47.957]                         else {
[17:29:47.957]                           version <- NULL
[17:29:47.957]                         }
[17:29:47.957]                         if (!has_future || version < "1.8.0") {
[17:29:47.957]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:47.957]                             "", base::R.version$version.string), 
[17:29:47.957]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:47.957]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:47.957]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:47.957]                               "release", "version")], collapse = " "), 
[17:29:47.957]                             hostname = base::Sys.info()[["nodename"]])
[17:29:47.957]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:47.957]                             info)
[17:29:47.957]                           info <- base::paste(info, collapse = "; ")
[17:29:47.957]                           if (!has_future) {
[17:29:47.957]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:47.957]                               info)
[17:29:47.957]                           }
[17:29:47.957]                           else {
[17:29:47.957]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:47.957]                               info, version)
[17:29:47.957]                           }
[17:29:47.957]                           base::stop(msg)
[17:29:47.957]                         }
[17:29:47.957]                       })
[17:29:47.957]                     }
[17:29:47.957]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:47.957]                     base::options(mc.cores = 1L)
[17:29:47.957]                   }
[17:29:47.957]                   ...future.strategy.old <- future::plan("list")
[17:29:47.957]                   options(future.plan = NULL)
[17:29:47.957]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.957]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:47.957]                 }
[17:29:47.957]                 ...future.workdir <- getwd()
[17:29:47.957]             }
[17:29:47.957]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:47.957]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:47.957]         }
[17:29:47.957]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:47.957]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:47.957]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:47.957]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:47.957]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:47.957]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:47.957]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:47.957]             base::names(...future.oldOptions))
[17:29:47.957]     }
[17:29:47.957]     if (FALSE) {
[17:29:47.957]     }
[17:29:47.957]     else {
[17:29:47.957]         if (TRUE) {
[17:29:47.957]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:47.957]                 open = "w")
[17:29:47.957]         }
[17:29:47.957]         else {
[17:29:47.957]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:47.957]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:47.957]         }
[17:29:47.957]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:47.957]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:47.957]             base::sink(type = "output", split = FALSE)
[17:29:47.957]             base::close(...future.stdout)
[17:29:47.957]         }, add = TRUE)
[17:29:47.957]     }
[17:29:47.957]     ...future.frame <- base::sys.nframe()
[17:29:47.957]     ...future.conditions <- base::list()
[17:29:47.957]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:47.957]     if (FALSE) {
[17:29:47.957]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:47.957]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:47.957]     }
[17:29:47.957]     ...future.result <- base::tryCatch({
[17:29:47.957]         base::withCallingHandlers({
[17:29:47.957]             ...future.value <- base::withVisible(base::local({
[17:29:47.957]                 ...future.makeSendCondition <- base::local({
[17:29:47.957]                   sendCondition <- NULL
[17:29:47.957]                   function(frame = 1L) {
[17:29:47.957]                     if (is.function(sendCondition)) 
[17:29:47.957]                       return(sendCondition)
[17:29:47.957]                     ns <- getNamespace("parallel")
[17:29:47.957]                     if (exists("sendData", mode = "function", 
[17:29:47.957]                       envir = ns)) {
[17:29:47.957]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:47.957]                         envir = ns)
[17:29:47.957]                       envir <- sys.frame(frame)
[17:29:47.957]                       master <- NULL
[17:29:47.957]                       while (!identical(envir, .GlobalEnv) && 
[17:29:47.957]                         !identical(envir, emptyenv())) {
[17:29:47.957]                         if (exists("master", mode = "list", envir = envir, 
[17:29:47.957]                           inherits = FALSE)) {
[17:29:47.957]                           master <- get("master", mode = "list", 
[17:29:47.957]                             envir = envir, inherits = FALSE)
[17:29:47.957]                           if (inherits(master, c("SOCKnode", 
[17:29:47.957]                             "SOCK0node"))) {
[17:29:47.957]                             sendCondition <<- function(cond) {
[17:29:47.957]                               data <- list(type = "VALUE", value = cond, 
[17:29:47.957]                                 success = TRUE)
[17:29:47.957]                               parallel_sendData(master, data)
[17:29:47.957]                             }
[17:29:47.957]                             return(sendCondition)
[17:29:47.957]                           }
[17:29:47.957]                         }
[17:29:47.957]                         frame <- frame + 1L
[17:29:47.957]                         envir <- sys.frame(frame)
[17:29:47.957]                       }
[17:29:47.957]                     }
[17:29:47.957]                     sendCondition <<- function(cond) NULL
[17:29:47.957]                   }
[17:29:47.957]                 })
[17:29:47.957]                 withCallingHandlers({
[17:29:47.957]                   {
[17:29:47.957]                     sample(x, size = 1L)
[17:29:47.957]                   }
[17:29:47.957]                 }, immediateCondition = function(cond) {
[17:29:47.957]                   sendCondition <- ...future.makeSendCondition()
[17:29:47.957]                   sendCondition(cond)
[17:29:47.957]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.957]                   {
[17:29:47.957]                     inherits <- base::inherits
[17:29:47.957]                     invokeRestart <- base::invokeRestart
[17:29:47.957]                     is.null <- base::is.null
[17:29:47.957]                     muffled <- FALSE
[17:29:47.957]                     if (inherits(cond, "message")) {
[17:29:47.957]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:47.957]                       if (muffled) 
[17:29:47.957]                         invokeRestart("muffleMessage")
[17:29:47.957]                     }
[17:29:47.957]                     else if (inherits(cond, "warning")) {
[17:29:47.957]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:47.957]                       if (muffled) 
[17:29:47.957]                         invokeRestart("muffleWarning")
[17:29:47.957]                     }
[17:29:47.957]                     else if (inherits(cond, "condition")) {
[17:29:47.957]                       if (!is.null(pattern)) {
[17:29:47.957]                         computeRestarts <- base::computeRestarts
[17:29:47.957]                         grepl <- base::grepl
[17:29:47.957]                         restarts <- computeRestarts(cond)
[17:29:47.957]                         for (restart in restarts) {
[17:29:47.957]                           name <- restart$name
[17:29:47.957]                           if (is.null(name)) 
[17:29:47.957]                             next
[17:29:47.957]                           if (!grepl(pattern, name)) 
[17:29:47.957]                             next
[17:29:47.957]                           invokeRestart(restart)
[17:29:47.957]                           muffled <- TRUE
[17:29:47.957]                           break
[17:29:47.957]                         }
[17:29:47.957]                       }
[17:29:47.957]                     }
[17:29:47.957]                     invisible(muffled)
[17:29:47.957]                   }
[17:29:47.957]                   muffleCondition(cond)
[17:29:47.957]                 })
[17:29:47.957]             }))
[17:29:47.957]             future::FutureResult(value = ...future.value$value, 
[17:29:47.957]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.957]                   ...future.rng), globalenv = if (FALSE) 
[17:29:47.957]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:47.957]                     ...future.globalenv.names))
[17:29:47.957]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:47.957]         }, condition = base::local({
[17:29:47.957]             c <- base::c
[17:29:47.957]             inherits <- base::inherits
[17:29:47.957]             invokeRestart <- base::invokeRestart
[17:29:47.957]             length <- base::length
[17:29:47.957]             list <- base::list
[17:29:47.957]             seq.int <- base::seq.int
[17:29:47.957]             signalCondition <- base::signalCondition
[17:29:47.957]             sys.calls <- base::sys.calls
[17:29:47.957]             `[[` <- base::`[[`
[17:29:47.957]             `+` <- base::`+`
[17:29:47.957]             `<<-` <- base::`<<-`
[17:29:47.957]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:47.957]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:47.957]                   3L)]
[17:29:47.957]             }
[17:29:47.957]             function(cond) {
[17:29:47.957]                 is_error <- inherits(cond, "error")
[17:29:47.957]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:47.957]                   NULL)
[17:29:47.957]                 if (is_error) {
[17:29:47.957]                   sessionInformation <- function() {
[17:29:47.957]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:47.957]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:47.957]                       search = base::search(), system = base::Sys.info())
[17:29:47.957]                   }
[17:29:47.957]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.957]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:47.957]                     cond$call), session = sessionInformation(), 
[17:29:47.957]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:47.957]                   signalCondition(cond)
[17:29:47.957]                 }
[17:29:47.957]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:47.957]                 "immediateCondition"))) {
[17:29:47.957]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:47.957]                   ...future.conditions[[length(...future.conditions) + 
[17:29:47.957]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:47.957]                   if (TRUE && !signal) {
[17:29:47.957]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.957]                     {
[17:29:47.957]                       inherits <- base::inherits
[17:29:47.957]                       invokeRestart <- base::invokeRestart
[17:29:47.957]                       is.null <- base::is.null
[17:29:47.957]                       muffled <- FALSE
[17:29:47.957]                       if (inherits(cond, "message")) {
[17:29:47.957]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.957]                         if (muffled) 
[17:29:47.957]                           invokeRestart("muffleMessage")
[17:29:47.957]                       }
[17:29:47.957]                       else if (inherits(cond, "warning")) {
[17:29:47.957]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.957]                         if (muffled) 
[17:29:47.957]                           invokeRestart("muffleWarning")
[17:29:47.957]                       }
[17:29:47.957]                       else if (inherits(cond, "condition")) {
[17:29:47.957]                         if (!is.null(pattern)) {
[17:29:47.957]                           computeRestarts <- base::computeRestarts
[17:29:47.957]                           grepl <- base::grepl
[17:29:47.957]                           restarts <- computeRestarts(cond)
[17:29:47.957]                           for (restart in restarts) {
[17:29:47.957]                             name <- restart$name
[17:29:47.957]                             if (is.null(name)) 
[17:29:47.957]                               next
[17:29:47.957]                             if (!grepl(pattern, name)) 
[17:29:47.957]                               next
[17:29:47.957]                             invokeRestart(restart)
[17:29:47.957]                             muffled <- TRUE
[17:29:47.957]                             break
[17:29:47.957]                           }
[17:29:47.957]                         }
[17:29:47.957]                       }
[17:29:47.957]                       invisible(muffled)
[17:29:47.957]                     }
[17:29:47.957]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.957]                   }
[17:29:47.957]                 }
[17:29:47.957]                 else {
[17:29:47.957]                   if (TRUE) {
[17:29:47.957]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:47.957]                     {
[17:29:47.957]                       inherits <- base::inherits
[17:29:47.957]                       invokeRestart <- base::invokeRestart
[17:29:47.957]                       is.null <- base::is.null
[17:29:47.957]                       muffled <- FALSE
[17:29:47.957]                       if (inherits(cond, "message")) {
[17:29:47.957]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:47.957]                         if (muffled) 
[17:29:47.957]                           invokeRestart("muffleMessage")
[17:29:47.957]                       }
[17:29:47.957]                       else if (inherits(cond, "warning")) {
[17:29:47.957]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:47.957]                         if (muffled) 
[17:29:47.957]                           invokeRestart("muffleWarning")
[17:29:47.957]                       }
[17:29:47.957]                       else if (inherits(cond, "condition")) {
[17:29:47.957]                         if (!is.null(pattern)) {
[17:29:47.957]                           computeRestarts <- base::computeRestarts
[17:29:47.957]                           grepl <- base::grepl
[17:29:47.957]                           restarts <- computeRestarts(cond)
[17:29:47.957]                           for (restart in restarts) {
[17:29:47.957]                             name <- restart$name
[17:29:47.957]                             if (is.null(name)) 
[17:29:47.957]                               next
[17:29:47.957]                             if (!grepl(pattern, name)) 
[17:29:47.957]                               next
[17:29:47.957]                             invokeRestart(restart)
[17:29:47.957]                             muffled <- TRUE
[17:29:47.957]                             break
[17:29:47.957]                           }
[17:29:47.957]                         }
[17:29:47.957]                       }
[17:29:47.957]                       invisible(muffled)
[17:29:47.957]                     }
[17:29:47.957]                     muffleCondition(cond, pattern = "^muffle")
[17:29:47.957]                   }
[17:29:47.957]                 }
[17:29:47.957]             }
[17:29:47.957]         }))
[17:29:47.957]     }, error = function(ex) {
[17:29:47.957]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:47.957]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:47.957]                 ...future.rng), started = ...future.startTime, 
[17:29:47.957]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:47.957]             version = "1.8"), class = "FutureResult")
[17:29:47.957]     }, finally = {
[17:29:47.957]         if (!identical(...future.workdir, getwd())) 
[17:29:47.957]             setwd(...future.workdir)
[17:29:47.957]         {
[17:29:47.957]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:47.957]                 ...future.oldOptions$nwarnings <- NULL
[17:29:47.957]             }
[17:29:47.957]             base::options(...future.oldOptions)
[17:29:47.957]             if (.Platform$OS.type == "windows") {
[17:29:47.957]                 old_names <- names(...future.oldEnvVars)
[17:29:47.957]                 envs <- base::Sys.getenv()
[17:29:47.957]                 names <- names(envs)
[17:29:47.957]                 common <- intersect(names, old_names)
[17:29:47.957]                 added <- setdiff(names, old_names)
[17:29:47.957]                 removed <- setdiff(old_names, names)
[17:29:47.957]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:47.957]                   envs[common]]
[17:29:47.957]                 NAMES <- toupper(changed)
[17:29:47.957]                 args <- list()
[17:29:47.957]                 for (kk in seq_along(NAMES)) {
[17:29:47.957]                   name <- changed[[kk]]
[17:29:47.957]                   NAME <- NAMES[[kk]]
[17:29:47.957]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.957]                     next
[17:29:47.957]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.957]                 }
[17:29:47.957]                 NAMES <- toupper(added)
[17:29:47.957]                 for (kk in seq_along(NAMES)) {
[17:29:47.957]                   name <- added[[kk]]
[17:29:47.957]                   NAME <- NAMES[[kk]]
[17:29:47.957]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.957]                     next
[17:29:47.957]                   args[[name]] <- ""
[17:29:47.957]                 }
[17:29:47.957]                 NAMES <- toupper(removed)
[17:29:47.957]                 for (kk in seq_along(NAMES)) {
[17:29:47.957]                   name <- removed[[kk]]
[17:29:47.957]                   NAME <- NAMES[[kk]]
[17:29:47.957]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:47.957]                     next
[17:29:47.957]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:47.957]                 }
[17:29:47.957]                 if (length(args) > 0) 
[17:29:47.957]                   base::do.call(base::Sys.setenv, args = args)
[17:29:47.957]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:47.957]             }
[17:29:47.957]             else {
[17:29:47.957]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:47.957]             }
[17:29:47.957]             {
[17:29:47.957]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:47.957]                   0L) {
[17:29:47.957]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:47.957]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:47.957]                   base::options(opts)
[17:29:47.957]                 }
[17:29:47.957]                 {
[17:29:47.957]                   {
[17:29:47.957]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:47.957]                     NULL
[17:29:47.957]                   }
[17:29:47.957]                   options(future.plan = NULL)
[17:29:47.957]                   if (is.na(NA_character_)) 
[17:29:47.957]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:47.957]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:47.957]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:47.957]                     .init = FALSE)
[17:29:47.957]                 }
[17:29:47.957]             }
[17:29:47.957]         }
[17:29:47.957]     })
[17:29:47.957]     if (TRUE) {
[17:29:47.957]         base::sink(type = "output", split = FALSE)
[17:29:47.957]         if (TRUE) {
[17:29:47.957]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:47.957]         }
[17:29:47.957]         else {
[17:29:47.957]             ...future.result["stdout"] <- base::list(NULL)
[17:29:47.957]         }
[17:29:47.957]         base::close(...future.stdout)
[17:29:47.957]         ...future.stdout <- NULL
[17:29:47.957]     }
[17:29:47.957]     ...future.result$conditions <- ...future.conditions
[17:29:47.957]     ...future.result$finished <- base::Sys.time()
[17:29:47.957]     ...future.result
[17:29:47.957] }
[17:29:47.965] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:47.989] receiveMessageFromWorker() for ClusterFuture ...
[17:29:47.989] - Validating connection of MultisessionFuture
[17:29:47.989] - received message: FutureResult
[17:29:47.990] - Received FutureResult
[17:29:47.990] - Erased future from FutureRegistry
[17:29:47.990] result() for ClusterFuture ...
[17:29:47.990] - result already collected: FutureResult
[17:29:47.990] result() for ClusterFuture ... done
[17:29:47.990] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:47.991] result() for ClusterFuture ...
[17:29:47.991] - result already collected: FutureResult
[17:29:47.991] result() for ClusterFuture ... done
[17:29:47.991] result() for ClusterFuture ...
[17:29:47.991] - result already collected: FutureResult
[17:29:47.991] result() for ClusterFuture ... done
[17:29:47.993] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:47.994] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:47.995] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:47.995] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:47.996] MultisessionFuture started
[17:29:47.997] - Launch lazy future ... done
[17:29:47.997] run() for 'MultisessionFuture' ... done
[17:29:47.998] getGlobalsAndPackages() ...
[17:29:47.999] Searching for globals...
[17:29:48.001] - globals found: [3] '{', 'sample', 'x'
[17:29:48.001] Searching for globals ... DONE
[17:29:48.001] Resolving globals: FALSE
[17:29:48.002] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:48.003] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:48.003] - globals: [1] 'x'
[17:29:48.004] 
[17:29:48.004] getGlobalsAndPackages() ... DONE
[17:29:48.005] run() for 'Future' ...
[17:29:48.005] - state: 'created'
[17:29:48.005] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:48.026] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:48.027] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:48.027]   - Field: 'node'
[17:29:48.028]   - Field: 'label'
[17:29:48.028]   - Field: 'local'
[17:29:48.028]   - Field: 'owner'
[17:29:48.029]   - Field: 'envir'
[17:29:48.029]   - Field: 'workers'
[17:29:48.029]   - Field: 'packages'
[17:29:48.029]   - Field: 'gc'
[17:29:48.030]   - Field: 'conditions'
[17:29:48.030]   - Field: 'persistent'
[17:29:48.030]   - Field: 'expr'
[17:29:48.031]   - Field: 'uuid'
[17:29:48.031]   - Field: 'seed'
[17:29:48.031]   - Field: 'version'
[17:29:48.031]   - Field: 'result'
[17:29:48.032]   - Field: 'asynchronous'
[17:29:48.032]   - Field: 'calls'
[17:29:48.032]   - Field: 'globals'
[17:29:48.033]   - Field: 'stdout'
[17:29:48.033]   - Field: 'earlySignal'
[17:29:48.033]   - Field: 'lazy'
[17:29:48.033]   - Field: 'state'
[17:29:48.034] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:48.034] - Launch lazy future ...
[17:29:48.035] Packages needed by the future expression (n = 0): <none>
[17:29:48.035] Packages needed by future strategies (n = 0): <none>
[17:29:48.036] {
[17:29:48.036]     {
[17:29:48.036]         {
[17:29:48.036]             ...future.startTime <- base::Sys.time()
[17:29:48.036]             {
[17:29:48.036]                 {
[17:29:48.036]                   {
[17:29:48.036]                     {
[17:29:48.036]                       base::local({
[17:29:48.036]                         has_future <- base::requireNamespace("future", 
[17:29:48.036]                           quietly = TRUE)
[17:29:48.036]                         if (has_future) {
[17:29:48.036]                           ns <- base::getNamespace("future")
[17:29:48.036]                           version <- ns[[".package"]][["version"]]
[17:29:48.036]                           if (is.null(version)) 
[17:29:48.036]                             version <- utils::packageVersion("future")
[17:29:48.036]                         }
[17:29:48.036]                         else {
[17:29:48.036]                           version <- NULL
[17:29:48.036]                         }
[17:29:48.036]                         if (!has_future || version < "1.8.0") {
[17:29:48.036]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:48.036]                             "", base::R.version$version.string), 
[17:29:48.036]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:48.036]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:48.036]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:48.036]                               "release", "version")], collapse = " "), 
[17:29:48.036]                             hostname = base::Sys.info()[["nodename"]])
[17:29:48.036]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:48.036]                             info)
[17:29:48.036]                           info <- base::paste(info, collapse = "; ")
[17:29:48.036]                           if (!has_future) {
[17:29:48.036]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:48.036]                               info)
[17:29:48.036]                           }
[17:29:48.036]                           else {
[17:29:48.036]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:48.036]                               info, version)
[17:29:48.036]                           }
[17:29:48.036]                           base::stop(msg)
[17:29:48.036]                         }
[17:29:48.036]                       })
[17:29:48.036]                     }
[17:29:48.036]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:48.036]                     base::options(mc.cores = 1L)
[17:29:48.036]                   }
[17:29:48.036]                   ...future.strategy.old <- future::plan("list")
[17:29:48.036]                   options(future.plan = NULL)
[17:29:48.036]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.036]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:48.036]                 }
[17:29:48.036]                 ...future.workdir <- getwd()
[17:29:48.036]             }
[17:29:48.036]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:48.036]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:48.036]         }
[17:29:48.036]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:48.036]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:48.036]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:48.036]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:48.036]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:48.036]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:48.036]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:48.036]             base::names(...future.oldOptions))
[17:29:48.036]     }
[17:29:48.036]     if (FALSE) {
[17:29:48.036]     }
[17:29:48.036]     else {
[17:29:48.036]         if (TRUE) {
[17:29:48.036]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:48.036]                 open = "w")
[17:29:48.036]         }
[17:29:48.036]         else {
[17:29:48.036]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:48.036]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:48.036]         }
[17:29:48.036]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:48.036]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:48.036]             base::sink(type = "output", split = FALSE)
[17:29:48.036]             base::close(...future.stdout)
[17:29:48.036]         }, add = TRUE)
[17:29:48.036]     }
[17:29:48.036]     ...future.frame <- base::sys.nframe()
[17:29:48.036]     ...future.conditions <- base::list()
[17:29:48.036]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:48.036]     if (FALSE) {
[17:29:48.036]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:48.036]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:48.036]     }
[17:29:48.036]     ...future.result <- base::tryCatch({
[17:29:48.036]         base::withCallingHandlers({
[17:29:48.036]             ...future.value <- base::withVisible(base::local({
[17:29:48.036]                 ...future.makeSendCondition <- base::local({
[17:29:48.036]                   sendCondition <- NULL
[17:29:48.036]                   function(frame = 1L) {
[17:29:48.036]                     if (is.function(sendCondition)) 
[17:29:48.036]                       return(sendCondition)
[17:29:48.036]                     ns <- getNamespace("parallel")
[17:29:48.036]                     if (exists("sendData", mode = "function", 
[17:29:48.036]                       envir = ns)) {
[17:29:48.036]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:48.036]                         envir = ns)
[17:29:48.036]                       envir <- sys.frame(frame)
[17:29:48.036]                       master <- NULL
[17:29:48.036]                       while (!identical(envir, .GlobalEnv) && 
[17:29:48.036]                         !identical(envir, emptyenv())) {
[17:29:48.036]                         if (exists("master", mode = "list", envir = envir, 
[17:29:48.036]                           inherits = FALSE)) {
[17:29:48.036]                           master <- get("master", mode = "list", 
[17:29:48.036]                             envir = envir, inherits = FALSE)
[17:29:48.036]                           if (inherits(master, c("SOCKnode", 
[17:29:48.036]                             "SOCK0node"))) {
[17:29:48.036]                             sendCondition <<- function(cond) {
[17:29:48.036]                               data <- list(type = "VALUE", value = cond, 
[17:29:48.036]                                 success = TRUE)
[17:29:48.036]                               parallel_sendData(master, data)
[17:29:48.036]                             }
[17:29:48.036]                             return(sendCondition)
[17:29:48.036]                           }
[17:29:48.036]                         }
[17:29:48.036]                         frame <- frame + 1L
[17:29:48.036]                         envir <- sys.frame(frame)
[17:29:48.036]                       }
[17:29:48.036]                     }
[17:29:48.036]                     sendCondition <<- function(cond) NULL
[17:29:48.036]                   }
[17:29:48.036]                 })
[17:29:48.036]                 withCallingHandlers({
[17:29:48.036]                   {
[17:29:48.036]                     sample(x, size = 1L)
[17:29:48.036]                   }
[17:29:48.036]                 }, immediateCondition = function(cond) {
[17:29:48.036]                   sendCondition <- ...future.makeSendCondition()
[17:29:48.036]                   sendCondition(cond)
[17:29:48.036]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.036]                   {
[17:29:48.036]                     inherits <- base::inherits
[17:29:48.036]                     invokeRestart <- base::invokeRestart
[17:29:48.036]                     is.null <- base::is.null
[17:29:48.036]                     muffled <- FALSE
[17:29:48.036]                     if (inherits(cond, "message")) {
[17:29:48.036]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:48.036]                       if (muffled) 
[17:29:48.036]                         invokeRestart("muffleMessage")
[17:29:48.036]                     }
[17:29:48.036]                     else if (inherits(cond, "warning")) {
[17:29:48.036]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:48.036]                       if (muffled) 
[17:29:48.036]                         invokeRestart("muffleWarning")
[17:29:48.036]                     }
[17:29:48.036]                     else if (inherits(cond, "condition")) {
[17:29:48.036]                       if (!is.null(pattern)) {
[17:29:48.036]                         computeRestarts <- base::computeRestarts
[17:29:48.036]                         grepl <- base::grepl
[17:29:48.036]                         restarts <- computeRestarts(cond)
[17:29:48.036]                         for (restart in restarts) {
[17:29:48.036]                           name <- restart$name
[17:29:48.036]                           if (is.null(name)) 
[17:29:48.036]                             next
[17:29:48.036]                           if (!grepl(pattern, name)) 
[17:29:48.036]                             next
[17:29:48.036]                           invokeRestart(restart)
[17:29:48.036]                           muffled <- TRUE
[17:29:48.036]                           break
[17:29:48.036]                         }
[17:29:48.036]                       }
[17:29:48.036]                     }
[17:29:48.036]                     invisible(muffled)
[17:29:48.036]                   }
[17:29:48.036]                   muffleCondition(cond)
[17:29:48.036]                 })
[17:29:48.036]             }))
[17:29:48.036]             future::FutureResult(value = ...future.value$value, 
[17:29:48.036]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.036]                   ...future.rng), globalenv = if (FALSE) 
[17:29:48.036]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:48.036]                     ...future.globalenv.names))
[17:29:48.036]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:48.036]         }, condition = base::local({
[17:29:48.036]             c <- base::c
[17:29:48.036]             inherits <- base::inherits
[17:29:48.036]             invokeRestart <- base::invokeRestart
[17:29:48.036]             length <- base::length
[17:29:48.036]             list <- base::list
[17:29:48.036]             seq.int <- base::seq.int
[17:29:48.036]             signalCondition <- base::signalCondition
[17:29:48.036]             sys.calls <- base::sys.calls
[17:29:48.036]             `[[` <- base::`[[`
[17:29:48.036]             `+` <- base::`+`
[17:29:48.036]             `<<-` <- base::`<<-`
[17:29:48.036]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:48.036]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:48.036]                   3L)]
[17:29:48.036]             }
[17:29:48.036]             function(cond) {
[17:29:48.036]                 is_error <- inherits(cond, "error")
[17:29:48.036]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:48.036]                   NULL)
[17:29:48.036]                 if (is_error) {
[17:29:48.036]                   sessionInformation <- function() {
[17:29:48.036]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:48.036]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:48.036]                       search = base::search(), system = base::Sys.info())
[17:29:48.036]                   }
[17:29:48.036]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.036]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:48.036]                     cond$call), session = sessionInformation(), 
[17:29:48.036]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:48.036]                   signalCondition(cond)
[17:29:48.036]                 }
[17:29:48.036]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:48.036]                 "immediateCondition"))) {
[17:29:48.036]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:48.036]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.036]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:48.036]                   if (TRUE && !signal) {
[17:29:48.036]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.036]                     {
[17:29:48.036]                       inherits <- base::inherits
[17:29:48.036]                       invokeRestart <- base::invokeRestart
[17:29:48.036]                       is.null <- base::is.null
[17:29:48.036]                       muffled <- FALSE
[17:29:48.036]                       if (inherits(cond, "message")) {
[17:29:48.036]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.036]                         if (muffled) 
[17:29:48.036]                           invokeRestart("muffleMessage")
[17:29:48.036]                       }
[17:29:48.036]                       else if (inherits(cond, "warning")) {
[17:29:48.036]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.036]                         if (muffled) 
[17:29:48.036]                           invokeRestart("muffleWarning")
[17:29:48.036]                       }
[17:29:48.036]                       else if (inherits(cond, "condition")) {
[17:29:48.036]                         if (!is.null(pattern)) {
[17:29:48.036]                           computeRestarts <- base::computeRestarts
[17:29:48.036]                           grepl <- base::grepl
[17:29:48.036]                           restarts <- computeRestarts(cond)
[17:29:48.036]                           for (restart in restarts) {
[17:29:48.036]                             name <- restart$name
[17:29:48.036]                             if (is.null(name)) 
[17:29:48.036]                               next
[17:29:48.036]                             if (!grepl(pattern, name)) 
[17:29:48.036]                               next
[17:29:48.036]                             invokeRestart(restart)
[17:29:48.036]                             muffled <- TRUE
[17:29:48.036]                             break
[17:29:48.036]                           }
[17:29:48.036]                         }
[17:29:48.036]                       }
[17:29:48.036]                       invisible(muffled)
[17:29:48.036]                     }
[17:29:48.036]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.036]                   }
[17:29:48.036]                 }
[17:29:48.036]                 else {
[17:29:48.036]                   if (TRUE) {
[17:29:48.036]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.036]                     {
[17:29:48.036]                       inherits <- base::inherits
[17:29:48.036]                       invokeRestart <- base::invokeRestart
[17:29:48.036]                       is.null <- base::is.null
[17:29:48.036]                       muffled <- FALSE
[17:29:48.036]                       if (inherits(cond, "message")) {
[17:29:48.036]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.036]                         if (muffled) 
[17:29:48.036]                           invokeRestart("muffleMessage")
[17:29:48.036]                       }
[17:29:48.036]                       else if (inherits(cond, "warning")) {
[17:29:48.036]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.036]                         if (muffled) 
[17:29:48.036]                           invokeRestart("muffleWarning")
[17:29:48.036]                       }
[17:29:48.036]                       else if (inherits(cond, "condition")) {
[17:29:48.036]                         if (!is.null(pattern)) {
[17:29:48.036]                           computeRestarts <- base::computeRestarts
[17:29:48.036]                           grepl <- base::grepl
[17:29:48.036]                           restarts <- computeRestarts(cond)
[17:29:48.036]                           for (restart in restarts) {
[17:29:48.036]                             name <- restart$name
[17:29:48.036]                             if (is.null(name)) 
[17:29:48.036]                               next
[17:29:48.036]                             if (!grepl(pattern, name)) 
[17:29:48.036]                               next
[17:29:48.036]                             invokeRestart(restart)
[17:29:48.036]                             muffled <- TRUE
[17:29:48.036]                             break
[17:29:48.036]                           }
[17:29:48.036]                         }
[17:29:48.036]                       }
[17:29:48.036]                       invisible(muffled)
[17:29:48.036]                     }
[17:29:48.036]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.036]                   }
[17:29:48.036]                 }
[17:29:48.036]             }
[17:29:48.036]         }))
[17:29:48.036]     }, error = function(ex) {
[17:29:48.036]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:48.036]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.036]                 ...future.rng), started = ...future.startTime, 
[17:29:48.036]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:48.036]             version = "1.8"), class = "FutureResult")
[17:29:48.036]     }, finally = {
[17:29:48.036]         if (!identical(...future.workdir, getwd())) 
[17:29:48.036]             setwd(...future.workdir)
[17:29:48.036]         {
[17:29:48.036]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:48.036]                 ...future.oldOptions$nwarnings <- NULL
[17:29:48.036]             }
[17:29:48.036]             base::options(...future.oldOptions)
[17:29:48.036]             if (.Platform$OS.type == "windows") {
[17:29:48.036]                 old_names <- names(...future.oldEnvVars)
[17:29:48.036]                 envs <- base::Sys.getenv()
[17:29:48.036]                 names <- names(envs)
[17:29:48.036]                 common <- intersect(names, old_names)
[17:29:48.036]                 added <- setdiff(names, old_names)
[17:29:48.036]                 removed <- setdiff(old_names, names)
[17:29:48.036]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:48.036]                   envs[common]]
[17:29:48.036]                 NAMES <- toupper(changed)
[17:29:48.036]                 args <- list()
[17:29:48.036]                 for (kk in seq_along(NAMES)) {
[17:29:48.036]                   name <- changed[[kk]]
[17:29:48.036]                   NAME <- NAMES[[kk]]
[17:29:48.036]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.036]                     next
[17:29:48.036]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.036]                 }
[17:29:48.036]                 NAMES <- toupper(added)
[17:29:48.036]                 for (kk in seq_along(NAMES)) {
[17:29:48.036]                   name <- added[[kk]]
[17:29:48.036]                   NAME <- NAMES[[kk]]
[17:29:48.036]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.036]                     next
[17:29:48.036]                   args[[name]] <- ""
[17:29:48.036]                 }
[17:29:48.036]                 NAMES <- toupper(removed)
[17:29:48.036]                 for (kk in seq_along(NAMES)) {
[17:29:48.036]                   name <- removed[[kk]]
[17:29:48.036]                   NAME <- NAMES[[kk]]
[17:29:48.036]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.036]                     next
[17:29:48.036]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.036]                 }
[17:29:48.036]                 if (length(args) > 0) 
[17:29:48.036]                   base::do.call(base::Sys.setenv, args = args)
[17:29:48.036]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:48.036]             }
[17:29:48.036]             else {
[17:29:48.036]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:48.036]             }
[17:29:48.036]             {
[17:29:48.036]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:48.036]                   0L) {
[17:29:48.036]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:48.036]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:48.036]                   base::options(opts)
[17:29:48.036]                 }
[17:29:48.036]                 {
[17:29:48.036]                   {
[17:29:48.036]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:48.036]                     NULL
[17:29:48.036]                   }
[17:29:48.036]                   options(future.plan = NULL)
[17:29:48.036]                   if (is.na(NA_character_)) 
[17:29:48.036]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.036]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:48.036]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:48.036]                     .init = FALSE)
[17:29:48.036]                 }
[17:29:48.036]             }
[17:29:48.036]         }
[17:29:48.036]     })
[17:29:48.036]     if (TRUE) {
[17:29:48.036]         base::sink(type = "output", split = FALSE)
[17:29:48.036]         if (TRUE) {
[17:29:48.036]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:48.036]         }
[17:29:48.036]         else {
[17:29:48.036]             ...future.result["stdout"] <- base::list(NULL)
[17:29:48.036]         }
[17:29:48.036]         base::close(...future.stdout)
[17:29:48.036]         ...future.stdout <- NULL
[17:29:48.036]     }
[17:29:48.036]     ...future.result$conditions <- ...future.conditions
[17:29:48.036]     ...future.result$finished <- base::Sys.time()
[17:29:48.036]     ...future.result
[17:29:48.036] }
[17:29:48.044] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:48.067] receiveMessageFromWorker() for ClusterFuture ...
[17:29:48.067] - Validating connection of MultisessionFuture
[17:29:48.068] - received message: FutureResult
[17:29:48.068] - Received FutureResult
[17:29:48.068] - Erased future from FutureRegistry
[17:29:48.069] result() for ClusterFuture ...
[17:29:48.069] - result already collected: FutureResult
[17:29:48.069] result() for ClusterFuture ... done
[17:29:48.069] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:48.070] result() for ClusterFuture ...
[17:29:48.070] - result already collected: FutureResult
[17:29:48.070] result() for ClusterFuture ... done
[17:29:48.071] result() for ClusterFuture ...
[17:29:48.071] - result already collected: FutureResult
[17:29:48.071] result() for ClusterFuture ... done
[17:29:48.073] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:48.074] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:48.074] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:48.075] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:48.076] MultisessionFuture started
[17:29:48.076] - Launch lazy future ... done
[17:29:48.076] run() for 'MultisessionFuture' ... done
[17:29:48.077] result() for ClusterFuture ...
[17:29:48.077] - result already collected: FutureResult
[17:29:48.077] result() for ClusterFuture ... done
[17:29:48.078] result() for ClusterFuture ...
[17:29:48.078] - result already collected: FutureResult
[17:29:48.078] result() for ClusterFuture ... done
[17:29:48.079] signalConditions() ...
[17:29:48.079]  - include = 'immediateCondition'
[17:29:48.079]  - exclude = 
[17:29:48.079]  - resignal = FALSE
[17:29:48.080]  - Number of conditions: 1
[17:29:48.080] signalConditions() ... done
[17:29:48.081] Future state: 'finished'
[17:29:48.081] result() for ClusterFuture ...
[17:29:48.081] - result already collected: FutureResult
[17:29:48.081] result() for ClusterFuture ... done
[17:29:48.082] signalConditions() ...
[17:29:48.082]  - include = 'condition'
[17:29:48.082]  - exclude = 'immediateCondition'
[17:29:48.083]  - resignal = TRUE
[17:29:48.083]  - Number of conditions: 1
[17:29:48.083]  - Condition #1: 'RngFutureWarning', 'FutureWarning', 'warning', 'RngFutureCondition', 'FutureCondition', 'condition'
[17:29:48.084] signalConditions() ... done
<RngFutureWarning: UNRELIABLE VALUE: Future ('fsample_1-757701') 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: 9880a6d0-6fe9-6afa-fa12-1c18c282073d


DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
MultisessionFuture:
Label: 'fsample_1-757701'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001add8b9e6f8
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Conditions captured: [n=1] 'RngFutureWarning'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'

DEBUG: END TROUBLESHOOTING HELP
[17:29:48.087] getGlobalsAndPackages() ...
[17:29:48.087] Searching for globals...
[17:29:48.089] - globals found: [3] '{', 'sample', 'x'
[17:29:48.090] Searching for globals ... DONE
[17:29:48.090] Resolving globals: FALSE
[17:29:48.091] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:48.092] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:48.092] - globals: [1] 'x'
[17:29:48.092] 
[17:29:48.093] getGlobalsAndPackages() ... DONE
[17:29:48.093] run() for 'Future' ...
[17:29:48.094] - state: 'created'
[17:29:48.094] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:48.112] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:48.113] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:48.113]   - Field: 'node'
[17:29:48.113]   - Field: 'label'
[17:29:48.113]   - Field: 'local'
[17:29:48.114]   - Field: 'owner'
[17:29:48.114]   - Field: 'envir'
[17:29:48.114]   - Field: 'workers'
[17:29:48.114]   - Field: 'packages'
[17:29:48.114]   - Field: 'gc'
[17:29:48.115]   - Field: 'conditions'
[17:29:48.115]   - Field: 'persistent'
[17:29:48.115]   - Field: 'expr'
[17:29:48.116]   - Field: 'uuid'
[17:29:48.116]   - Field: 'seed'
[17:29:48.116]   - Field: 'version'
[17:29:48.116]   - Field: 'result'
[17:29:48.117]   - Field: 'asynchronous'
[17:29:48.117]   - Field: 'calls'
[17:29:48.117]   - Field: 'globals'
[17:29:48.117]   - Field: 'stdout'
[17:29:48.118]   - Field: 'earlySignal'
[17:29:48.118]   - Field: 'lazy'
[17:29:48.118]   - Field: 'state'
[17:29:48.118] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:48.119] - Launch lazy future ...
[17:29:48.119] Packages needed by the future expression (n = 0): <none>
[17:29:48.120] Packages needed by future strategies (n = 0): <none>
[17:29:48.120] {
[17:29:48.120]     {
[17:29:48.120]         {
[17:29:48.120]             ...future.startTime <- base::Sys.time()
[17:29:48.120]             {
[17:29:48.120]                 {
[17:29:48.120]                   {
[17:29:48.120]                     {
[17:29:48.120]                       base::local({
[17:29:48.120]                         has_future <- base::requireNamespace("future", 
[17:29:48.120]                           quietly = TRUE)
[17:29:48.120]                         if (has_future) {
[17:29:48.120]                           ns <- base::getNamespace("future")
[17:29:48.120]                           version <- ns[[".package"]][["version"]]
[17:29:48.120]                           if (is.null(version)) 
[17:29:48.120]                             version <- utils::packageVersion("future")
[17:29:48.120]                         }
[17:29:48.120]                         else {
[17:29:48.120]                           version <- NULL
[17:29:48.120]                         }
[17:29:48.120]                         if (!has_future || version < "1.8.0") {
[17:29:48.120]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:48.120]                             "", base::R.version$version.string), 
[17:29:48.120]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:48.120]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:48.120]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:48.120]                               "release", "version")], collapse = " "), 
[17:29:48.120]                             hostname = base::Sys.info()[["nodename"]])
[17:29:48.120]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:48.120]                             info)
[17:29:48.120]                           info <- base::paste(info, collapse = "; ")
[17:29:48.120]                           if (!has_future) {
[17:29:48.120]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:48.120]                               info)
[17:29:48.120]                           }
[17:29:48.120]                           else {
[17:29:48.120]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:48.120]                               info, version)
[17:29:48.120]                           }
[17:29:48.120]                           base::stop(msg)
[17:29:48.120]                         }
[17:29:48.120]                       })
[17:29:48.120]                     }
[17:29:48.120]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:48.120]                     base::options(mc.cores = 1L)
[17:29:48.120]                   }
[17:29:48.120]                   ...future.strategy.old <- future::plan("list")
[17:29:48.120]                   options(future.plan = NULL)
[17:29:48.120]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.120]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:48.120]                 }
[17:29:48.120]                 ...future.workdir <- getwd()
[17:29:48.120]             }
[17:29:48.120]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:48.120]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:48.120]         }
[17:29:48.120]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:48.120]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:48.120]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:48.120]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:48.120]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:48.120]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:48.120]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:48.120]             base::names(...future.oldOptions))
[17:29:48.120]     }
[17:29:48.120]     if (FALSE) {
[17:29:48.120]     }
[17:29:48.120]     else {
[17:29:48.120]         if (TRUE) {
[17:29:48.120]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:48.120]                 open = "w")
[17:29:48.120]         }
[17:29:48.120]         else {
[17:29:48.120]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:48.120]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:48.120]         }
[17:29:48.120]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:48.120]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:48.120]             base::sink(type = "output", split = FALSE)
[17:29:48.120]             base::close(...future.stdout)
[17:29:48.120]         }, add = TRUE)
[17:29:48.120]     }
[17:29:48.120]     ...future.frame <- base::sys.nframe()
[17:29:48.120]     ...future.conditions <- base::list()
[17:29:48.120]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:48.120]     if (FALSE) {
[17:29:48.120]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:48.120]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:48.120]     }
[17:29:48.120]     ...future.result <- base::tryCatch({
[17:29:48.120]         base::withCallingHandlers({
[17:29:48.120]             ...future.value <- base::withVisible(base::local({
[17:29:48.120]                 ...future.makeSendCondition <- base::local({
[17:29:48.120]                   sendCondition <- NULL
[17:29:48.120]                   function(frame = 1L) {
[17:29:48.120]                     if (is.function(sendCondition)) 
[17:29:48.120]                       return(sendCondition)
[17:29:48.120]                     ns <- getNamespace("parallel")
[17:29:48.120]                     if (exists("sendData", mode = "function", 
[17:29:48.120]                       envir = ns)) {
[17:29:48.120]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:48.120]                         envir = ns)
[17:29:48.120]                       envir <- sys.frame(frame)
[17:29:48.120]                       master <- NULL
[17:29:48.120]                       while (!identical(envir, .GlobalEnv) && 
[17:29:48.120]                         !identical(envir, emptyenv())) {
[17:29:48.120]                         if (exists("master", mode = "list", envir = envir, 
[17:29:48.120]                           inherits = FALSE)) {
[17:29:48.120]                           master <- get("master", mode = "list", 
[17:29:48.120]                             envir = envir, inherits = FALSE)
[17:29:48.120]                           if (inherits(master, c("SOCKnode", 
[17:29:48.120]                             "SOCK0node"))) {
[17:29:48.120]                             sendCondition <<- function(cond) {
[17:29:48.120]                               data <- list(type = "VALUE", value = cond, 
[17:29:48.120]                                 success = TRUE)
[17:29:48.120]                               parallel_sendData(master, data)
[17:29:48.120]                             }
[17:29:48.120]                             return(sendCondition)
[17:29:48.120]                           }
[17:29:48.120]                         }
[17:29:48.120]                         frame <- frame + 1L
[17:29:48.120]                         envir <- sys.frame(frame)
[17:29:48.120]                       }
[17:29:48.120]                     }
[17:29:48.120]                     sendCondition <<- function(cond) NULL
[17:29:48.120]                   }
[17:29:48.120]                 })
[17:29:48.120]                 withCallingHandlers({
[17:29:48.120]                   {
[17:29:48.120]                     sample(x, size = 1L)
[17:29:48.120]                   }
[17:29:48.120]                 }, immediateCondition = function(cond) {
[17:29:48.120]                   sendCondition <- ...future.makeSendCondition()
[17:29:48.120]                   sendCondition(cond)
[17:29:48.120]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.120]                   {
[17:29:48.120]                     inherits <- base::inherits
[17:29:48.120]                     invokeRestart <- base::invokeRestart
[17:29:48.120]                     is.null <- base::is.null
[17:29:48.120]                     muffled <- FALSE
[17:29:48.120]                     if (inherits(cond, "message")) {
[17:29:48.120]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:48.120]                       if (muffled) 
[17:29:48.120]                         invokeRestart("muffleMessage")
[17:29:48.120]                     }
[17:29:48.120]                     else if (inherits(cond, "warning")) {
[17:29:48.120]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:48.120]                       if (muffled) 
[17:29:48.120]                         invokeRestart("muffleWarning")
[17:29:48.120]                     }
[17:29:48.120]                     else if (inherits(cond, "condition")) {
[17:29:48.120]                       if (!is.null(pattern)) {
[17:29:48.120]                         computeRestarts <- base::computeRestarts
[17:29:48.120]                         grepl <- base::grepl
[17:29:48.120]                         restarts <- computeRestarts(cond)
[17:29:48.120]                         for (restart in restarts) {
[17:29:48.120]                           name <- restart$name
[17:29:48.120]                           if (is.null(name)) 
[17:29:48.120]                             next
[17:29:48.120]                           if (!grepl(pattern, name)) 
[17:29:48.120]                             next
[17:29:48.120]                           invokeRestart(restart)
[17:29:48.120]                           muffled <- TRUE
[17:29:48.120]                           break
[17:29:48.120]                         }
[17:29:48.120]                       }
[17:29:48.120]                     }
[17:29:48.120]                     invisible(muffled)
[17:29:48.120]                   }
[17:29:48.120]                   muffleCondition(cond)
[17:29:48.120]                 })
[17:29:48.120]             }))
[17:29:48.120]             future::FutureResult(value = ...future.value$value, 
[17:29:48.120]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.120]                   ...future.rng), globalenv = if (FALSE) 
[17:29:48.120]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:48.120]                     ...future.globalenv.names))
[17:29:48.120]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:48.120]         }, condition = base::local({
[17:29:48.120]             c <- base::c
[17:29:48.120]             inherits <- base::inherits
[17:29:48.120]             invokeRestart <- base::invokeRestart
[17:29:48.120]             length <- base::length
[17:29:48.120]             list <- base::list
[17:29:48.120]             seq.int <- base::seq.int
[17:29:48.120]             signalCondition <- base::signalCondition
[17:29:48.120]             sys.calls <- base::sys.calls
[17:29:48.120]             `[[` <- base::`[[`
[17:29:48.120]             `+` <- base::`+`
[17:29:48.120]             `<<-` <- base::`<<-`
[17:29:48.120]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:48.120]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:48.120]                   3L)]
[17:29:48.120]             }
[17:29:48.120]             function(cond) {
[17:29:48.120]                 is_error <- inherits(cond, "error")
[17:29:48.120]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:48.120]                   NULL)
[17:29:48.120]                 if (is_error) {
[17:29:48.120]                   sessionInformation <- function() {
[17:29:48.120]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:48.120]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:48.120]                       search = base::search(), system = base::Sys.info())
[17:29:48.120]                   }
[17:29:48.120]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.120]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:48.120]                     cond$call), session = sessionInformation(), 
[17:29:48.120]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:48.120]                   signalCondition(cond)
[17:29:48.120]                 }
[17:29:48.120]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:48.120]                 "immediateCondition"))) {
[17:29:48.120]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:48.120]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.120]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:48.120]                   if (TRUE && !signal) {
[17:29:48.120]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.120]                     {
[17:29:48.120]                       inherits <- base::inherits
[17:29:48.120]                       invokeRestart <- base::invokeRestart
[17:29:48.120]                       is.null <- base::is.null
[17:29:48.120]                       muffled <- FALSE
[17:29:48.120]                       if (inherits(cond, "message")) {
[17:29:48.120]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.120]                         if (muffled) 
[17:29:48.120]                           invokeRestart("muffleMessage")
[17:29:48.120]                       }
[17:29:48.120]                       else if (inherits(cond, "warning")) {
[17:29:48.120]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.120]                         if (muffled) 
[17:29:48.120]                           invokeRestart("muffleWarning")
[17:29:48.120]                       }
[17:29:48.120]                       else if (inherits(cond, "condition")) {
[17:29:48.120]                         if (!is.null(pattern)) {
[17:29:48.120]                           computeRestarts <- base::computeRestarts
[17:29:48.120]                           grepl <- base::grepl
[17:29:48.120]                           restarts <- computeRestarts(cond)
[17:29:48.120]                           for (restart in restarts) {
[17:29:48.120]                             name <- restart$name
[17:29:48.120]                             if (is.null(name)) 
[17:29:48.120]                               next
[17:29:48.120]                             if (!grepl(pattern, name)) 
[17:29:48.120]                               next
[17:29:48.120]                             invokeRestart(restart)
[17:29:48.120]                             muffled <- TRUE
[17:29:48.120]                             break
[17:29:48.120]                           }
[17:29:48.120]                         }
[17:29:48.120]                       }
[17:29:48.120]                       invisible(muffled)
[17:29:48.120]                     }
[17:29:48.120]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.120]                   }
[17:29:48.120]                 }
[17:29:48.120]                 else {
[17:29:48.120]                   if (TRUE) {
[17:29:48.120]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.120]                     {
[17:29:48.120]                       inherits <- base::inherits
[17:29:48.120]                       invokeRestart <- base::invokeRestart
[17:29:48.120]                       is.null <- base::is.null
[17:29:48.120]                       muffled <- FALSE
[17:29:48.120]                       if (inherits(cond, "message")) {
[17:29:48.120]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.120]                         if (muffled) 
[17:29:48.120]                           invokeRestart("muffleMessage")
[17:29:48.120]                       }
[17:29:48.120]                       else if (inherits(cond, "warning")) {
[17:29:48.120]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.120]                         if (muffled) 
[17:29:48.120]                           invokeRestart("muffleWarning")
[17:29:48.120]                       }
[17:29:48.120]                       else if (inherits(cond, "condition")) {
[17:29:48.120]                         if (!is.null(pattern)) {
[17:29:48.120]                           computeRestarts <- base::computeRestarts
[17:29:48.120]                           grepl <- base::grepl
[17:29:48.120]                           restarts <- computeRestarts(cond)
[17:29:48.120]                           for (restart in restarts) {
[17:29:48.120]                             name <- restart$name
[17:29:48.120]                             if (is.null(name)) 
[17:29:48.120]                               next
[17:29:48.120]                             if (!grepl(pattern, name)) 
[17:29:48.120]                               next
[17:29:48.120]                             invokeRestart(restart)
[17:29:48.120]                             muffled <- TRUE
[17:29:48.120]                             break
[17:29:48.120]                           }
[17:29:48.120]                         }
[17:29:48.120]                       }
[17:29:48.120]                       invisible(muffled)
[17:29:48.120]                     }
[17:29:48.120]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.120]                   }
[17:29:48.120]                 }
[17:29:48.120]             }
[17:29:48.120]         }))
[17:29:48.120]     }, error = function(ex) {
[17:29:48.120]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:48.120]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.120]                 ...future.rng), started = ...future.startTime, 
[17:29:48.120]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:48.120]             version = "1.8"), class = "FutureResult")
[17:29:48.120]     }, finally = {
[17:29:48.120]         if (!identical(...future.workdir, getwd())) 
[17:29:48.120]             setwd(...future.workdir)
[17:29:48.120]         {
[17:29:48.120]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:48.120]                 ...future.oldOptions$nwarnings <- NULL
[17:29:48.120]             }
[17:29:48.120]             base::options(...future.oldOptions)
[17:29:48.120]             if (.Platform$OS.type == "windows") {
[17:29:48.120]                 old_names <- names(...future.oldEnvVars)
[17:29:48.120]                 envs <- base::Sys.getenv()
[17:29:48.120]                 names <- names(envs)
[17:29:48.120]                 common <- intersect(names, old_names)
[17:29:48.120]                 added <- setdiff(names, old_names)
[17:29:48.120]                 removed <- setdiff(old_names, names)
[17:29:48.120]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:48.120]                   envs[common]]
[17:29:48.120]                 NAMES <- toupper(changed)
[17:29:48.120]                 args <- list()
[17:29:48.120]                 for (kk in seq_along(NAMES)) {
[17:29:48.120]                   name <- changed[[kk]]
[17:29:48.120]                   NAME <- NAMES[[kk]]
[17:29:48.120]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.120]                     next
[17:29:48.120]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.120]                 }
[17:29:48.120]                 NAMES <- toupper(added)
[17:29:48.120]                 for (kk in seq_along(NAMES)) {
[17:29:48.120]                   name <- added[[kk]]
[17:29:48.120]                   NAME <- NAMES[[kk]]
[17:29:48.120]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.120]                     next
[17:29:48.120]                   args[[name]] <- ""
[17:29:48.120]                 }
[17:29:48.120]                 NAMES <- toupper(removed)
[17:29:48.120]                 for (kk in seq_along(NAMES)) {
[17:29:48.120]                   name <- removed[[kk]]
[17:29:48.120]                   NAME <- NAMES[[kk]]
[17:29:48.120]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.120]                     next
[17:29:48.120]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.120]                 }
[17:29:48.120]                 if (length(args) > 0) 
[17:29:48.120]                   base::do.call(base::Sys.setenv, args = args)
[17:29:48.120]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:48.120]             }
[17:29:48.120]             else {
[17:29:48.120]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:48.120]             }
[17:29:48.120]             {
[17:29:48.120]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:48.120]                   0L) {
[17:29:48.120]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:48.120]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:48.120]                   base::options(opts)
[17:29:48.120]                 }
[17:29:48.120]                 {
[17:29:48.120]                   {
[17:29:48.120]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:48.120]                     NULL
[17:29:48.120]                   }
[17:29:48.120]                   options(future.plan = NULL)
[17:29:48.120]                   if (is.na(NA_character_)) 
[17:29:48.120]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.120]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:48.120]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:48.120]                     .init = FALSE)
[17:29:48.120]                 }
[17:29:48.120]             }
[17:29:48.120]         }
[17:29:48.120]     })
[17:29:48.120]     if (TRUE) {
[17:29:48.120]         base::sink(type = "output", split = FALSE)
[17:29:48.120]         if (TRUE) {
[17:29:48.120]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:48.120]         }
[17:29:48.120]         else {
[17:29:48.120]             ...future.result["stdout"] <- base::list(NULL)
[17:29:48.120]         }
[17:29:48.120]         base::close(...future.stdout)
[17:29:48.120]         ...future.stdout <- NULL
[17:29:48.120]     }
[17:29:48.120]     ...future.result$conditions <- ...future.conditions
[17:29:48.120]     ...future.result$finished <- base::Sys.time()
[17:29:48.120]     ...future.result
[17:29:48.120] }
[17:29:48.128] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:48.145] receiveMessageFromWorker() for ClusterFuture ...
[17:29:48.145] - Validating connection of MultisessionFuture
[17:29:48.146] - received message: FutureResult
[17:29:48.146] - Received FutureResult
[17:29:48.147] - Erased future from FutureRegistry
[17:29:48.147] result() for ClusterFuture ...
[17:29:48.147] - result already collected: FutureResult
[17:29:48.147] result() for ClusterFuture ... done
[17:29:48.148] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:48.148] result() for ClusterFuture ...
[17:29:48.148] - result already collected: FutureResult
[17:29:48.148] result() for ClusterFuture ... done
[17:29:48.149] result() for ClusterFuture ...
[17:29:48.149] - result already collected: FutureResult
[17:29:48.149] result() for ClusterFuture ... done
[17:29:48.151] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:48.152] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:48.152] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:48.153] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:48.154] MultisessionFuture started
[17:29:48.154] - Launch lazy future ... done
[17:29:48.154] run() for 'MultisessionFuture' ... done
[17:29:48.155] getGlobalsAndPackages() ...
[17:29:48.155] Searching for globals...
[17:29:48.157] - globals found: [3] '{', 'sample', 'x'
[17:29:48.158] Searching for globals ... DONE
[17:29:48.158] Resolving globals: FALSE
[17:29:48.158] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:48.159] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:48.159] - globals: [1] 'x'
[17:29:48.160] 
[17:29:48.160] getGlobalsAndPackages() ... DONE
[17:29:48.161] run() for 'Future' ...
[17:29:48.161] - state: 'created'
[17:29:48.161] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:48.179] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:48.179] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:48.180]   - Field: 'node'
[17:29:48.180]   - Field: 'label'
[17:29:48.180]   - Field: 'local'
[17:29:48.181]   - Field: 'owner'
[17:29:48.181]   - Field: 'envir'
[17:29:48.181]   - Field: 'workers'
[17:29:48.181]   - Field: 'packages'
[17:29:48.181]   - Field: 'gc'
[17:29:48.182]   - Field: 'conditions'
[17:29:48.182]   - Field: 'persistent'
[17:29:48.182]   - Field: 'expr'
[17:29:48.182]   - Field: 'uuid'
[17:29:48.183]   - Field: 'seed'
[17:29:48.183]   - Field: 'version'
[17:29:48.183]   - Field: 'result'
[17:29:48.183]   - Field: 'asynchronous'
[17:29:48.184]   - Field: 'calls'
[17:29:48.184]   - Field: 'globals'
[17:29:48.184]   - Field: 'stdout'
[17:29:48.184]   - Field: 'earlySignal'
[17:29:48.184]   - Field: 'lazy'
[17:29:48.185]   - Field: 'state'
[17:29:48.185] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:48.185] - Launch lazy future ...
[17:29:48.186] Packages needed by the future expression (n = 0): <none>
[17:29:48.186] Packages needed by future strategies (n = 0): <none>
[17:29:48.187] {
[17:29:48.187]     {
[17:29:48.187]         {
[17:29:48.187]             ...future.startTime <- base::Sys.time()
[17:29:48.187]             {
[17:29:48.187]                 {
[17:29:48.187]                   {
[17:29:48.187]                     {
[17:29:48.187]                       base::local({
[17:29:48.187]                         has_future <- base::requireNamespace("future", 
[17:29:48.187]                           quietly = TRUE)
[17:29:48.187]                         if (has_future) {
[17:29:48.187]                           ns <- base::getNamespace("future")
[17:29:48.187]                           version <- ns[[".package"]][["version"]]
[17:29:48.187]                           if (is.null(version)) 
[17:29:48.187]                             version <- utils::packageVersion("future")
[17:29:48.187]                         }
[17:29:48.187]                         else {
[17:29:48.187]                           version <- NULL
[17:29:48.187]                         }
[17:29:48.187]                         if (!has_future || version < "1.8.0") {
[17:29:48.187]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:48.187]                             "", base::R.version$version.string), 
[17:29:48.187]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:48.187]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:48.187]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:48.187]                               "release", "version")], collapse = " "), 
[17:29:48.187]                             hostname = base::Sys.info()[["nodename"]])
[17:29:48.187]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:48.187]                             info)
[17:29:48.187]                           info <- base::paste(info, collapse = "; ")
[17:29:48.187]                           if (!has_future) {
[17:29:48.187]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:48.187]                               info)
[17:29:48.187]                           }
[17:29:48.187]                           else {
[17:29:48.187]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:48.187]                               info, version)
[17:29:48.187]                           }
[17:29:48.187]                           base::stop(msg)
[17:29:48.187]                         }
[17:29:48.187]                       })
[17:29:48.187]                     }
[17:29:48.187]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:48.187]                     base::options(mc.cores = 1L)
[17:29:48.187]                   }
[17:29:48.187]                   ...future.strategy.old <- future::plan("list")
[17:29:48.187]                   options(future.plan = NULL)
[17:29:48.187]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.187]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:48.187]                 }
[17:29:48.187]                 ...future.workdir <- getwd()
[17:29:48.187]             }
[17:29:48.187]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:48.187]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:48.187]         }
[17:29:48.187]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:48.187]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:48.187]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:48.187]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:48.187]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:48.187]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:48.187]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:48.187]             base::names(...future.oldOptions))
[17:29:48.187]     }
[17:29:48.187]     if (FALSE) {
[17:29:48.187]     }
[17:29:48.187]     else {
[17:29:48.187]         if (TRUE) {
[17:29:48.187]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:48.187]                 open = "w")
[17:29:48.187]         }
[17:29:48.187]         else {
[17:29:48.187]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:48.187]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:48.187]         }
[17:29:48.187]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:48.187]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:48.187]             base::sink(type = "output", split = FALSE)
[17:29:48.187]             base::close(...future.stdout)
[17:29:48.187]         }, add = TRUE)
[17:29:48.187]     }
[17:29:48.187]     ...future.frame <- base::sys.nframe()
[17:29:48.187]     ...future.conditions <- base::list()
[17:29:48.187]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:48.187]     if (FALSE) {
[17:29:48.187]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:48.187]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:48.187]     }
[17:29:48.187]     ...future.result <- base::tryCatch({
[17:29:48.187]         base::withCallingHandlers({
[17:29:48.187]             ...future.value <- base::withVisible(base::local({
[17:29:48.187]                 ...future.makeSendCondition <- base::local({
[17:29:48.187]                   sendCondition <- NULL
[17:29:48.187]                   function(frame = 1L) {
[17:29:48.187]                     if (is.function(sendCondition)) 
[17:29:48.187]                       return(sendCondition)
[17:29:48.187]                     ns <- getNamespace("parallel")
[17:29:48.187]                     if (exists("sendData", mode = "function", 
[17:29:48.187]                       envir = ns)) {
[17:29:48.187]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:48.187]                         envir = ns)
[17:29:48.187]                       envir <- sys.frame(frame)
[17:29:48.187]                       master <- NULL
[17:29:48.187]                       while (!identical(envir, .GlobalEnv) && 
[17:29:48.187]                         !identical(envir, emptyenv())) {
[17:29:48.187]                         if (exists("master", mode = "list", envir = envir, 
[17:29:48.187]                           inherits = FALSE)) {
[17:29:48.187]                           master <- get("master", mode = "list", 
[17:29:48.187]                             envir = envir, inherits = FALSE)
[17:29:48.187]                           if (inherits(master, c("SOCKnode", 
[17:29:48.187]                             "SOCK0node"))) {
[17:29:48.187]                             sendCondition <<- function(cond) {
[17:29:48.187]                               data <- list(type = "VALUE", value = cond, 
[17:29:48.187]                                 success = TRUE)
[17:29:48.187]                               parallel_sendData(master, data)
[17:29:48.187]                             }
[17:29:48.187]                             return(sendCondition)
[17:29:48.187]                           }
[17:29:48.187]                         }
[17:29:48.187]                         frame <- frame + 1L
[17:29:48.187]                         envir <- sys.frame(frame)
[17:29:48.187]                       }
[17:29:48.187]                     }
[17:29:48.187]                     sendCondition <<- function(cond) NULL
[17:29:48.187]                   }
[17:29:48.187]                 })
[17:29:48.187]                 withCallingHandlers({
[17:29:48.187]                   {
[17:29:48.187]                     sample(x, size = 1L)
[17:29:48.187]                   }
[17:29:48.187]                 }, immediateCondition = function(cond) {
[17:29:48.187]                   sendCondition <- ...future.makeSendCondition()
[17:29:48.187]                   sendCondition(cond)
[17:29:48.187]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.187]                   {
[17:29:48.187]                     inherits <- base::inherits
[17:29:48.187]                     invokeRestart <- base::invokeRestart
[17:29:48.187]                     is.null <- base::is.null
[17:29:48.187]                     muffled <- FALSE
[17:29:48.187]                     if (inherits(cond, "message")) {
[17:29:48.187]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:48.187]                       if (muffled) 
[17:29:48.187]                         invokeRestart("muffleMessage")
[17:29:48.187]                     }
[17:29:48.187]                     else if (inherits(cond, "warning")) {
[17:29:48.187]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:48.187]                       if (muffled) 
[17:29:48.187]                         invokeRestart("muffleWarning")
[17:29:48.187]                     }
[17:29:48.187]                     else if (inherits(cond, "condition")) {
[17:29:48.187]                       if (!is.null(pattern)) {
[17:29:48.187]                         computeRestarts <- base::computeRestarts
[17:29:48.187]                         grepl <- base::grepl
[17:29:48.187]                         restarts <- computeRestarts(cond)
[17:29:48.187]                         for (restart in restarts) {
[17:29:48.187]                           name <- restart$name
[17:29:48.187]                           if (is.null(name)) 
[17:29:48.187]                             next
[17:29:48.187]                           if (!grepl(pattern, name)) 
[17:29:48.187]                             next
[17:29:48.187]                           invokeRestart(restart)
[17:29:48.187]                           muffled <- TRUE
[17:29:48.187]                           break
[17:29:48.187]                         }
[17:29:48.187]                       }
[17:29:48.187]                     }
[17:29:48.187]                     invisible(muffled)
[17:29:48.187]                   }
[17:29:48.187]                   muffleCondition(cond)
[17:29:48.187]                 })
[17:29:48.187]             }))
[17:29:48.187]             future::FutureResult(value = ...future.value$value, 
[17:29:48.187]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.187]                   ...future.rng), globalenv = if (FALSE) 
[17:29:48.187]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:48.187]                     ...future.globalenv.names))
[17:29:48.187]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:48.187]         }, condition = base::local({
[17:29:48.187]             c <- base::c
[17:29:48.187]             inherits <- base::inherits
[17:29:48.187]             invokeRestart <- base::invokeRestart
[17:29:48.187]             length <- base::length
[17:29:48.187]             list <- base::list
[17:29:48.187]             seq.int <- base::seq.int
[17:29:48.187]             signalCondition <- base::signalCondition
[17:29:48.187]             sys.calls <- base::sys.calls
[17:29:48.187]             `[[` <- base::`[[`
[17:29:48.187]             `+` <- base::`+`
[17:29:48.187]             `<<-` <- base::`<<-`
[17:29:48.187]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:48.187]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:48.187]                   3L)]
[17:29:48.187]             }
[17:29:48.187]             function(cond) {
[17:29:48.187]                 is_error <- inherits(cond, "error")
[17:29:48.187]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:48.187]                   NULL)
[17:29:48.187]                 if (is_error) {
[17:29:48.187]                   sessionInformation <- function() {
[17:29:48.187]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:48.187]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:48.187]                       search = base::search(), system = base::Sys.info())
[17:29:48.187]                   }
[17:29:48.187]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.187]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:48.187]                     cond$call), session = sessionInformation(), 
[17:29:48.187]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:48.187]                   signalCondition(cond)
[17:29:48.187]                 }
[17:29:48.187]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:48.187]                 "immediateCondition"))) {
[17:29:48.187]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:48.187]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.187]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:48.187]                   if (TRUE && !signal) {
[17:29:48.187]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.187]                     {
[17:29:48.187]                       inherits <- base::inherits
[17:29:48.187]                       invokeRestart <- base::invokeRestart
[17:29:48.187]                       is.null <- base::is.null
[17:29:48.187]                       muffled <- FALSE
[17:29:48.187]                       if (inherits(cond, "message")) {
[17:29:48.187]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.187]                         if (muffled) 
[17:29:48.187]                           invokeRestart("muffleMessage")
[17:29:48.187]                       }
[17:29:48.187]                       else if (inherits(cond, "warning")) {
[17:29:48.187]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.187]                         if (muffled) 
[17:29:48.187]                           invokeRestart("muffleWarning")
[17:29:48.187]                       }
[17:29:48.187]                       else if (inherits(cond, "condition")) {
[17:29:48.187]                         if (!is.null(pattern)) {
[17:29:48.187]                           computeRestarts <- base::computeRestarts
[17:29:48.187]                           grepl <- base::grepl
[17:29:48.187]                           restarts <- computeRestarts(cond)
[17:29:48.187]                           for (restart in restarts) {
[17:29:48.187]                             name <- restart$name
[17:29:48.187]                             if (is.null(name)) 
[17:29:48.187]                               next
[17:29:48.187]                             if (!grepl(pattern, name)) 
[17:29:48.187]                               next
[17:29:48.187]                             invokeRestart(restart)
[17:29:48.187]                             muffled <- TRUE
[17:29:48.187]                             break
[17:29:48.187]                           }
[17:29:48.187]                         }
[17:29:48.187]                       }
[17:29:48.187]                       invisible(muffled)
[17:29:48.187]                     }
[17:29:48.187]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.187]                   }
[17:29:48.187]                 }
[17:29:48.187]                 else {
[17:29:48.187]                   if (TRUE) {
[17:29:48.187]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.187]                     {
[17:29:48.187]                       inherits <- base::inherits
[17:29:48.187]                       invokeRestart <- base::invokeRestart
[17:29:48.187]                       is.null <- base::is.null
[17:29:48.187]                       muffled <- FALSE
[17:29:48.187]                       if (inherits(cond, "message")) {
[17:29:48.187]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.187]                         if (muffled) 
[17:29:48.187]                           invokeRestart("muffleMessage")
[17:29:48.187]                       }
[17:29:48.187]                       else if (inherits(cond, "warning")) {
[17:29:48.187]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.187]                         if (muffled) 
[17:29:48.187]                           invokeRestart("muffleWarning")
[17:29:48.187]                       }
[17:29:48.187]                       else if (inherits(cond, "condition")) {
[17:29:48.187]                         if (!is.null(pattern)) {
[17:29:48.187]                           computeRestarts <- base::computeRestarts
[17:29:48.187]                           grepl <- base::grepl
[17:29:48.187]                           restarts <- computeRestarts(cond)
[17:29:48.187]                           for (restart in restarts) {
[17:29:48.187]                             name <- restart$name
[17:29:48.187]                             if (is.null(name)) 
[17:29:48.187]                               next
[17:29:48.187]                             if (!grepl(pattern, name)) 
[17:29:48.187]                               next
[17:29:48.187]                             invokeRestart(restart)
[17:29:48.187]                             muffled <- TRUE
[17:29:48.187]                             break
[17:29:48.187]                           }
[17:29:48.187]                         }
[17:29:48.187]                       }
[17:29:48.187]                       invisible(muffled)
[17:29:48.187]                     }
[17:29:48.187]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.187]                   }
[17:29:48.187]                 }
[17:29:48.187]             }
[17:29:48.187]         }))
[17:29:48.187]     }, error = function(ex) {
[17:29:48.187]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:48.187]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.187]                 ...future.rng), started = ...future.startTime, 
[17:29:48.187]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:48.187]             version = "1.8"), class = "FutureResult")
[17:29:48.187]     }, finally = {
[17:29:48.187]         if (!identical(...future.workdir, getwd())) 
[17:29:48.187]             setwd(...future.workdir)
[17:29:48.187]         {
[17:29:48.187]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:48.187]                 ...future.oldOptions$nwarnings <- NULL
[17:29:48.187]             }
[17:29:48.187]             base::options(...future.oldOptions)
[17:29:48.187]             if (.Platform$OS.type == "windows") {
[17:29:48.187]                 old_names <- names(...future.oldEnvVars)
[17:29:48.187]                 envs <- base::Sys.getenv()
[17:29:48.187]                 names <- names(envs)
[17:29:48.187]                 common <- intersect(names, old_names)
[17:29:48.187]                 added <- setdiff(names, old_names)
[17:29:48.187]                 removed <- setdiff(old_names, names)
[17:29:48.187]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:48.187]                   envs[common]]
[17:29:48.187]                 NAMES <- toupper(changed)
[17:29:48.187]                 args <- list()
[17:29:48.187]                 for (kk in seq_along(NAMES)) {
[17:29:48.187]                   name <- changed[[kk]]
[17:29:48.187]                   NAME <- NAMES[[kk]]
[17:29:48.187]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.187]                     next
[17:29:48.187]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.187]                 }
[17:29:48.187]                 NAMES <- toupper(added)
[17:29:48.187]                 for (kk in seq_along(NAMES)) {
[17:29:48.187]                   name <- added[[kk]]
[17:29:48.187]                   NAME <- NAMES[[kk]]
[17:29:48.187]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.187]                     next
[17:29:48.187]                   args[[name]] <- ""
[17:29:48.187]                 }
[17:29:48.187]                 NAMES <- toupper(removed)
[17:29:48.187]                 for (kk in seq_along(NAMES)) {
[17:29:48.187]                   name <- removed[[kk]]
[17:29:48.187]                   NAME <- NAMES[[kk]]
[17:29:48.187]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.187]                     next
[17:29:48.187]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.187]                 }
[17:29:48.187]                 if (length(args) > 0) 
[17:29:48.187]                   base::do.call(base::Sys.setenv, args = args)
[17:29:48.187]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:48.187]             }
[17:29:48.187]             else {
[17:29:48.187]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:48.187]             }
[17:29:48.187]             {
[17:29:48.187]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:48.187]                   0L) {
[17:29:48.187]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:48.187]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:48.187]                   base::options(opts)
[17:29:48.187]                 }
[17:29:48.187]                 {
[17:29:48.187]                   {
[17:29:48.187]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:48.187]                     NULL
[17:29:48.187]                   }
[17:29:48.187]                   options(future.plan = NULL)
[17:29:48.187]                   if (is.na(NA_character_)) 
[17:29:48.187]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.187]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:48.187]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:48.187]                     .init = FALSE)
[17:29:48.187]                 }
[17:29:48.187]             }
[17:29:48.187]         }
[17:29:48.187]     })
[17:29:48.187]     if (TRUE) {
[17:29:48.187]         base::sink(type = "output", split = FALSE)
[17:29:48.187]         if (TRUE) {
[17:29:48.187]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:48.187]         }
[17:29:48.187]         else {
[17:29:48.187]             ...future.result["stdout"] <- base::list(NULL)
[17:29:48.187]         }
[17:29:48.187]         base::close(...future.stdout)
[17:29:48.187]         ...future.stdout <- NULL
[17:29:48.187]     }
[17:29:48.187]     ...future.result$conditions <- ...future.conditions
[17:29:48.187]     ...future.result$finished <- base::Sys.time()
[17:29:48.187]     ...future.result
[17:29:48.187] }
[17:29:48.193] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:48.207] receiveMessageFromWorker() for ClusterFuture ...
[17:29:48.208] - Validating connection of MultisessionFuture
[17:29:48.208] - received message: FutureResult
[17:29:48.208] - Received FutureResult
[17:29:48.209] - Erased future from FutureRegistry
[17:29:48.209] result() for ClusterFuture ...
[17:29:48.209] - result already collected: FutureResult
[17:29:48.210] result() for ClusterFuture ... done
[17:29:48.210] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:48.210] result() for ClusterFuture ...
[17:29:48.210] - result already collected: FutureResult
[17:29:48.211] result() for ClusterFuture ... done
[17:29:48.211] result() for ClusterFuture ...
[17:29:48.211] - result already collected: FutureResult
[17:29:48.211] result() for ClusterFuture ... done
[17:29:48.212] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:48.213] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:48.213] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:48.214] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:48.214] MultisessionFuture started
[17:29:48.214] - Launch lazy future ... done
[17:29:48.215] run() for 'MultisessionFuture' ... done
[17:29:48.215] getGlobalsAndPackages() ...
[17:29:48.216] Searching for globals...
[17:29:48.217] - globals found: [3] '{', 'sample', 'x'
[17:29:48.217] Searching for globals ... DONE
[17:29:48.217] Resolving globals: FALSE
[17:29:48.218] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:48.218] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:48.218] - globals: [1] 'x'
[17:29:48.219] 
[17:29:48.219] getGlobalsAndPackages() ... DONE
[17:29:48.219] run() for 'Future' ...
[17:29:48.219] - state: 'created'
[17:29:48.220] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:48.237] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:48.238] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:48.238]   - Field: 'node'
[17:29:48.239]   - Field: 'label'
[17:29:48.239]   - Field: 'local'
[17:29:48.239]   - Field: 'owner'
[17:29:48.240]   - Field: 'envir'
[17:29:48.240]   - Field: 'workers'
[17:29:48.240]   - Field: 'packages'
[17:29:48.240]   - Field: 'gc'
[17:29:48.241]   - Field: 'conditions'
[17:29:48.241]   - Field: 'persistent'
[17:29:48.241]   - Field: 'expr'
[17:29:48.242]   - Field: 'uuid'
[17:29:48.242]   - Field: 'seed'
[17:29:48.242]   - Field: 'version'
[17:29:48.243]   - Field: 'result'
[17:29:48.243]   - Field: 'asynchronous'
[17:29:48.243]   - Field: 'calls'
[17:29:48.243]   - Field: 'globals'
[17:29:48.244]   - Field: 'stdout'
[17:29:48.244]   - Field: 'earlySignal'
[17:29:48.244]   - Field: 'lazy'
[17:29:48.245]   - Field: 'state'
[17:29:48.245] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:48.245] - Launch lazy future ...
[17:29:48.246] Packages needed by the future expression (n = 0): <none>
[17:29:48.246] Packages needed by future strategies (n = 0): <none>
[17:29:48.247] {
[17:29:48.247]     {
[17:29:48.247]         {
[17:29:48.247]             ...future.startTime <- base::Sys.time()
[17:29:48.247]             {
[17:29:48.247]                 {
[17:29:48.247]                   {
[17:29:48.247]                     {
[17:29:48.247]                       base::local({
[17:29:48.247]                         has_future <- base::requireNamespace("future", 
[17:29:48.247]                           quietly = TRUE)
[17:29:48.247]                         if (has_future) {
[17:29:48.247]                           ns <- base::getNamespace("future")
[17:29:48.247]                           version <- ns[[".package"]][["version"]]
[17:29:48.247]                           if (is.null(version)) 
[17:29:48.247]                             version <- utils::packageVersion("future")
[17:29:48.247]                         }
[17:29:48.247]                         else {
[17:29:48.247]                           version <- NULL
[17:29:48.247]                         }
[17:29:48.247]                         if (!has_future || version < "1.8.0") {
[17:29:48.247]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:48.247]                             "", base::R.version$version.string), 
[17:29:48.247]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:48.247]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:48.247]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:48.247]                               "release", "version")], collapse = " "), 
[17:29:48.247]                             hostname = base::Sys.info()[["nodename"]])
[17:29:48.247]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:48.247]                             info)
[17:29:48.247]                           info <- base::paste(info, collapse = "; ")
[17:29:48.247]                           if (!has_future) {
[17:29:48.247]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:48.247]                               info)
[17:29:48.247]                           }
[17:29:48.247]                           else {
[17:29:48.247]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:48.247]                               info, version)
[17:29:48.247]                           }
[17:29:48.247]                           base::stop(msg)
[17:29:48.247]                         }
[17:29:48.247]                       })
[17:29:48.247]                     }
[17:29:48.247]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:48.247]                     base::options(mc.cores = 1L)
[17:29:48.247]                   }
[17:29:48.247]                   ...future.strategy.old <- future::plan("list")
[17:29:48.247]                   options(future.plan = NULL)
[17:29:48.247]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.247]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:48.247]                 }
[17:29:48.247]                 ...future.workdir <- getwd()
[17:29:48.247]             }
[17:29:48.247]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:48.247]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:48.247]         }
[17:29:48.247]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:48.247]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:48.247]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:48.247]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:48.247]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:48.247]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:48.247]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:48.247]             base::names(...future.oldOptions))
[17:29:48.247]     }
[17:29:48.247]     if (FALSE) {
[17:29:48.247]     }
[17:29:48.247]     else {
[17:29:48.247]         if (TRUE) {
[17:29:48.247]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:48.247]                 open = "w")
[17:29:48.247]         }
[17:29:48.247]         else {
[17:29:48.247]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:48.247]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:48.247]         }
[17:29:48.247]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:48.247]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:48.247]             base::sink(type = "output", split = FALSE)
[17:29:48.247]             base::close(...future.stdout)
[17:29:48.247]         }, add = TRUE)
[17:29:48.247]     }
[17:29:48.247]     ...future.frame <- base::sys.nframe()
[17:29:48.247]     ...future.conditions <- base::list()
[17:29:48.247]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:48.247]     if (FALSE) {
[17:29:48.247]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:48.247]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:48.247]     }
[17:29:48.247]     ...future.result <- base::tryCatch({
[17:29:48.247]         base::withCallingHandlers({
[17:29:48.247]             ...future.value <- base::withVisible(base::local({
[17:29:48.247]                 ...future.makeSendCondition <- base::local({
[17:29:48.247]                   sendCondition <- NULL
[17:29:48.247]                   function(frame = 1L) {
[17:29:48.247]                     if (is.function(sendCondition)) 
[17:29:48.247]                       return(sendCondition)
[17:29:48.247]                     ns <- getNamespace("parallel")
[17:29:48.247]                     if (exists("sendData", mode = "function", 
[17:29:48.247]                       envir = ns)) {
[17:29:48.247]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:48.247]                         envir = ns)
[17:29:48.247]                       envir <- sys.frame(frame)
[17:29:48.247]                       master <- NULL
[17:29:48.247]                       while (!identical(envir, .GlobalEnv) && 
[17:29:48.247]                         !identical(envir, emptyenv())) {
[17:29:48.247]                         if (exists("master", mode = "list", envir = envir, 
[17:29:48.247]                           inherits = FALSE)) {
[17:29:48.247]                           master <- get("master", mode = "list", 
[17:29:48.247]                             envir = envir, inherits = FALSE)
[17:29:48.247]                           if (inherits(master, c("SOCKnode", 
[17:29:48.247]                             "SOCK0node"))) {
[17:29:48.247]                             sendCondition <<- function(cond) {
[17:29:48.247]                               data <- list(type = "VALUE", value = cond, 
[17:29:48.247]                                 success = TRUE)
[17:29:48.247]                               parallel_sendData(master, data)
[17:29:48.247]                             }
[17:29:48.247]                             return(sendCondition)
[17:29:48.247]                           }
[17:29:48.247]                         }
[17:29:48.247]                         frame <- frame + 1L
[17:29:48.247]                         envir <- sys.frame(frame)
[17:29:48.247]                       }
[17:29:48.247]                     }
[17:29:48.247]                     sendCondition <<- function(cond) NULL
[17:29:48.247]                   }
[17:29:48.247]                 })
[17:29:48.247]                 withCallingHandlers({
[17:29:48.247]                   {
[17:29:48.247]                     sample(x, size = 1L)
[17:29:48.247]                   }
[17:29:48.247]                 }, immediateCondition = function(cond) {
[17:29:48.247]                   sendCondition <- ...future.makeSendCondition()
[17:29:48.247]                   sendCondition(cond)
[17:29:48.247]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.247]                   {
[17:29:48.247]                     inherits <- base::inherits
[17:29:48.247]                     invokeRestart <- base::invokeRestart
[17:29:48.247]                     is.null <- base::is.null
[17:29:48.247]                     muffled <- FALSE
[17:29:48.247]                     if (inherits(cond, "message")) {
[17:29:48.247]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:48.247]                       if (muffled) 
[17:29:48.247]                         invokeRestart("muffleMessage")
[17:29:48.247]                     }
[17:29:48.247]                     else if (inherits(cond, "warning")) {
[17:29:48.247]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:48.247]                       if (muffled) 
[17:29:48.247]                         invokeRestart("muffleWarning")
[17:29:48.247]                     }
[17:29:48.247]                     else if (inherits(cond, "condition")) {
[17:29:48.247]                       if (!is.null(pattern)) {
[17:29:48.247]                         computeRestarts <- base::computeRestarts
[17:29:48.247]                         grepl <- base::grepl
[17:29:48.247]                         restarts <- computeRestarts(cond)
[17:29:48.247]                         for (restart in restarts) {
[17:29:48.247]                           name <- restart$name
[17:29:48.247]                           if (is.null(name)) 
[17:29:48.247]                             next
[17:29:48.247]                           if (!grepl(pattern, name)) 
[17:29:48.247]                             next
[17:29:48.247]                           invokeRestart(restart)
[17:29:48.247]                           muffled <- TRUE
[17:29:48.247]                           break
[17:29:48.247]                         }
[17:29:48.247]                       }
[17:29:48.247]                     }
[17:29:48.247]                     invisible(muffled)
[17:29:48.247]                   }
[17:29:48.247]                   muffleCondition(cond)
[17:29:48.247]                 })
[17:29:48.247]             }))
[17:29:48.247]             future::FutureResult(value = ...future.value$value, 
[17:29:48.247]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.247]                   ...future.rng), globalenv = if (FALSE) 
[17:29:48.247]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:48.247]                     ...future.globalenv.names))
[17:29:48.247]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:48.247]         }, condition = base::local({
[17:29:48.247]             c <- base::c
[17:29:48.247]             inherits <- base::inherits
[17:29:48.247]             invokeRestart <- base::invokeRestart
[17:29:48.247]             length <- base::length
[17:29:48.247]             list <- base::list
[17:29:48.247]             seq.int <- base::seq.int
[17:29:48.247]             signalCondition <- base::signalCondition
[17:29:48.247]             sys.calls <- base::sys.calls
[17:29:48.247]             `[[` <- base::`[[`
[17:29:48.247]             `+` <- base::`+`
[17:29:48.247]             `<<-` <- base::`<<-`
[17:29:48.247]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:48.247]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:48.247]                   3L)]
[17:29:48.247]             }
[17:29:48.247]             function(cond) {
[17:29:48.247]                 is_error <- inherits(cond, "error")
[17:29:48.247]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:48.247]                   NULL)
[17:29:48.247]                 if (is_error) {
[17:29:48.247]                   sessionInformation <- function() {
[17:29:48.247]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:48.247]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:48.247]                       search = base::search(), system = base::Sys.info())
[17:29:48.247]                   }
[17:29:48.247]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.247]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:48.247]                     cond$call), session = sessionInformation(), 
[17:29:48.247]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:48.247]                   signalCondition(cond)
[17:29:48.247]                 }
[17:29:48.247]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:48.247]                 "immediateCondition"))) {
[17:29:48.247]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:48.247]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.247]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:48.247]                   if (TRUE && !signal) {
[17:29:48.247]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.247]                     {
[17:29:48.247]                       inherits <- base::inherits
[17:29:48.247]                       invokeRestart <- base::invokeRestart
[17:29:48.247]                       is.null <- base::is.null
[17:29:48.247]                       muffled <- FALSE
[17:29:48.247]                       if (inherits(cond, "message")) {
[17:29:48.247]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.247]                         if (muffled) 
[17:29:48.247]                           invokeRestart("muffleMessage")
[17:29:48.247]                       }
[17:29:48.247]                       else if (inherits(cond, "warning")) {
[17:29:48.247]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.247]                         if (muffled) 
[17:29:48.247]                           invokeRestart("muffleWarning")
[17:29:48.247]                       }
[17:29:48.247]                       else if (inherits(cond, "condition")) {
[17:29:48.247]                         if (!is.null(pattern)) {
[17:29:48.247]                           computeRestarts <- base::computeRestarts
[17:29:48.247]                           grepl <- base::grepl
[17:29:48.247]                           restarts <- computeRestarts(cond)
[17:29:48.247]                           for (restart in restarts) {
[17:29:48.247]                             name <- restart$name
[17:29:48.247]                             if (is.null(name)) 
[17:29:48.247]                               next
[17:29:48.247]                             if (!grepl(pattern, name)) 
[17:29:48.247]                               next
[17:29:48.247]                             invokeRestart(restart)
[17:29:48.247]                             muffled <- TRUE
[17:29:48.247]                             break
[17:29:48.247]                           }
[17:29:48.247]                         }
[17:29:48.247]                       }
[17:29:48.247]                       invisible(muffled)
[17:29:48.247]                     }
[17:29:48.247]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.247]                   }
[17:29:48.247]                 }
[17:29:48.247]                 else {
[17:29:48.247]                   if (TRUE) {
[17:29:48.247]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.247]                     {
[17:29:48.247]                       inherits <- base::inherits
[17:29:48.247]                       invokeRestart <- base::invokeRestart
[17:29:48.247]                       is.null <- base::is.null
[17:29:48.247]                       muffled <- FALSE
[17:29:48.247]                       if (inherits(cond, "message")) {
[17:29:48.247]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.247]                         if (muffled) 
[17:29:48.247]                           invokeRestart("muffleMessage")
[17:29:48.247]                       }
[17:29:48.247]                       else if (inherits(cond, "warning")) {
[17:29:48.247]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.247]                         if (muffled) 
[17:29:48.247]                           invokeRestart("muffleWarning")
[17:29:48.247]                       }
[17:29:48.247]                       else if (inherits(cond, "condition")) {
[17:29:48.247]                         if (!is.null(pattern)) {
[17:29:48.247]                           computeRestarts <- base::computeRestarts
[17:29:48.247]                           grepl <- base::grepl
[17:29:48.247]                           restarts <- computeRestarts(cond)
[17:29:48.247]                           for (restart in restarts) {
[17:29:48.247]                             name <- restart$name
[17:29:48.247]                             if (is.null(name)) 
[17:29:48.247]                               next
[17:29:48.247]                             if (!grepl(pattern, name)) 
[17:29:48.247]                               next
[17:29:48.247]                             invokeRestart(restart)
[17:29:48.247]                             muffled <- TRUE
[17:29:48.247]                             break
[17:29:48.247]                           }
[17:29:48.247]                         }
[17:29:48.247]                       }
[17:29:48.247]                       invisible(muffled)
[17:29:48.247]                     }
[17:29:48.247]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.247]                   }
[17:29:48.247]                 }
[17:29:48.247]             }
[17:29:48.247]         }))
[17:29:48.247]     }, error = function(ex) {
[17:29:48.247]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:48.247]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.247]                 ...future.rng), started = ...future.startTime, 
[17:29:48.247]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:48.247]             version = "1.8"), class = "FutureResult")
[17:29:48.247]     }, finally = {
[17:29:48.247]         if (!identical(...future.workdir, getwd())) 
[17:29:48.247]             setwd(...future.workdir)
[17:29:48.247]         {
[17:29:48.247]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:48.247]                 ...future.oldOptions$nwarnings <- NULL
[17:29:48.247]             }
[17:29:48.247]             base::options(...future.oldOptions)
[17:29:48.247]             if (.Platform$OS.type == "windows") {
[17:29:48.247]                 old_names <- names(...future.oldEnvVars)
[17:29:48.247]                 envs <- base::Sys.getenv()
[17:29:48.247]                 names <- names(envs)
[17:29:48.247]                 common <- intersect(names, old_names)
[17:29:48.247]                 added <- setdiff(names, old_names)
[17:29:48.247]                 removed <- setdiff(old_names, names)
[17:29:48.247]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:48.247]                   envs[common]]
[17:29:48.247]                 NAMES <- toupper(changed)
[17:29:48.247]                 args <- list()
[17:29:48.247]                 for (kk in seq_along(NAMES)) {
[17:29:48.247]                   name <- changed[[kk]]
[17:29:48.247]                   NAME <- NAMES[[kk]]
[17:29:48.247]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.247]                     next
[17:29:48.247]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.247]                 }
[17:29:48.247]                 NAMES <- toupper(added)
[17:29:48.247]                 for (kk in seq_along(NAMES)) {
[17:29:48.247]                   name <- added[[kk]]
[17:29:48.247]                   NAME <- NAMES[[kk]]
[17:29:48.247]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.247]                     next
[17:29:48.247]                   args[[name]] <- ""
[17:29:48.247]                 }
[17:29:48.247]                 NAMES <- toupper(removed)
[17:29:48.247]                 for (kk in seq_along(NAMES)) {
[17:29:48.247]                   name <- removed[[kk]]
[17:29:48.247]                   NAME <- NAMES[[kk]]
[17:29:48.247]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.247]                     next
[17:29:48.247]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.247]                 }
[17:29:48.247]                 if (length(args) > 0) 
[17:29:48.247]                   base::do.call(base::Sys.setenv, args = args)
[17:29:48.247]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:48.247]             }
[17:29:48.247]             else {
[17:29:48.247]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:48.247]             }
[17:29:48.247]             {
[17:29:48.247]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:48.247]                   0L) {
[17:29:48.247]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:48.247]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:48.247]                   base::options(opts)
[17:29:48.247]                 }
[17:29:48.247]                 {
[17:29:48.247]                   {
[17:29:48.247]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:48.247]                     NULL
[17:29:48.247]                   }
[17:29:48.247]                   options(future.plan = NULL)
[17:29:48.247]                   if (is.na(NA_character_)) 
[17:29:48.247]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.247]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:48.247]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:48.247]                     .init = FALSE)
[17:29:48.247]                 }
[17:29:48.247]             }
[17:29:48.247]         }
[17:29:48.247]     })
[17:29:48.247]     if (TRUE) {
[17:29:48.247]         base::sink(type = "output", split = FALSE)
[17:29:48.247]         if (TRUE) {
[17:29:48.247]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:48.247]         }
[17:29:48.247]         else {
[17:29:48.247]             ...future.result["stdout"] <- base::list(NULL)
[17:29:48.247]         }
[17:29:48.247]         base::close(...future.stdout)
[17:29:48.247]         ...future.stdout <- NULL
[17:29:48.247]     }
[17:29:48.247]     ...future.result$conditions <- ...future.conditions
[17:29:48.247]     ...future.result$finished <- base::Sys.time()
[17:29:48.247]     ...future.result
[17:29:48.247] }
[17:29:48.255] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:48.270] receiveMessageFromWorker() for ClusterFuture ...
[17:29:48.270] - Validating connection of MultisessionFuture
[17:29:48.271] - received message: FutureResult
[17:29:48.271] - Received FutureResult
[17:29:48.271] - Erased future from FutureRegistry
[17:29:48.271] result() for ClusterFuture ...
[17:29:48.272] - result already collected: FutureResult
[17:29:48.272] result() for ClusterFuture ... done
[17:29:48.272] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:48.273] result() for ClusterFuture ...
[17:29:48.273] - result already collected: FutureResult
[17:29:48.273] result() for ClusterFuture ... done
[17:29:48.273] result() for ClusterFuture ...
[17:29:48.274] - result already collected: FutureResult
[17:29:48.274] result() for ClusterFuture ... done
[17:29:48.275] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:48.276] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:48.276] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:48.276] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:48.277] MultisessionFuture started
[17:29:48.278] - Launch lazy future ... done
[17:29:48.278] run() for 'MultisessionFuture' ... done
[17:29:48.295] getGlobalsAndPackages() ...
[17:29:48.296] Searching for globals...
[17:29:48.298] - globals found: [3] '{', 'sample', 'x'
[17:29:48.299] Searching for globals ... DONE
[17:29:48.299] Resolving globals: FALSE
[17:29:48.300] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:48.301] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:48.301] - globals: [1] 'x'
[17:29:48.301] 
[17:29:48.302] getGlobalsAndPackages() ... DONE
[17:29:48.302] run() for 'Future' ...
[17:29:48.303] - state: 'created'
[17:29:48.303] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:48.322] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:48.323] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:48.323]   - Field: 'node'
[17:29:48.323]   - Field: 'label'
[17:29:48.324]   - Field: 'local'
[17:29:48.324]   - Field: 'owner'
[17:29:48.324]   - Field: 'envir'
[17:29:48.325]   - Field: 'workers'
[17:29:48.325]   - Field: 'packages'
[17:29:48.325]   - Field: 'gc'
[17:29:48.325]   - Field: 'conditions'
[17:29:48.326]   - Field: 'persistent'
[17:29:48.326]   - Field: 'expr'
[17:29:48.326]   - Field: 'uuid'
[17:29:48.327]   - Field: 'seed'
[17:29:48.327]   - Field: 'version'
[17:29:48.327]   - Field: 'result'
[17:29:48.327]   - Field: 'asynchronous'
[17:29:48.327]   - Field: 'calls'
[17:29:48.327]   - Field: 'globals'
[17:29:48.328]   - Field: 'stdout'
[17:29:48.328]   - Field: 'earlySignal'
[17:29:48.328]   - Field: 'lazy'
[17:29:48.328]   - Field: 'state'
[17:29:48.329] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:48.329] - Launch lazy future ...
[17:29:48.330] Packages needed by the future expression (n = 0): <none>
[17:29:48.330] Packages needed by future strategies (n = 0): <none>
[17:29:48.331] {
[17:29:48.331]     {
[17:29:48.331]         {
[17:29:48.331]             ...future.startTime <- base::Sys.time()
[17:29:48.331]             {
[17:29:48.331]                 {
[17:29:48.331]                   {
[17:29:48.331]                     {
[17:29:48.331]                       base::local({
[17:29:48.331]                         has_future <- base::requireNamespace("future", 
[17:29:48.331]                           quietly = TRUE)
[17:29:48.331]                         if (has_future) {
[17:29:48.331]                           ns <- base::getNamespace("future")
[17:29:48.331]                           version <- ns[[".package"]][["version"]]
[17:29:48.331]                           if (is.null(version)) 
[17:29:48.331]                             version <- utils::packageVersion("future")
[17:29:48.331]                         }
[17:29:48.331]                         else {
[17:29:48.331]                           version <- NULL
[17:29:48.331]                         }
[17:29:48.331]                         if (!has_future || version < "1.8.0") {
[17:29:48.331]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:48.331]                             "", base::R.version$version.string), 
[17:29:48.331]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:48.331]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:48.331]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:48.331]                               "release", "version")], collapse = " "), 
[17:29:48.331]                             hostname = base::Sys.info()[["nodename"]])
[17:29:48.331]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:48.331]                             info)
[17:29:48.331]                           info <- base::paste(info, collapse = "; ")
[17:29:48.331]                           if (!has_future) {
[17:29:48.331]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:48.331]                               info)
[17:29:48.331]                           }
[17:29:48.331]                           else {
[17:29:48.331]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:48.331]                               info, version)
[17:29:48.331]                           }
[17:29:48.331]                           base::stop(msg)
[17:29:48.331]                         }
[17:29:48.331]                       })
[17:29:48.331]                     }
[17:29:48.331]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:48.331]                     base::options(mc.cores = 1L)
[17:29:48.331]                   }
[17:29:48.331]                   ...future.strategy.old <- future::plan("list")
[17:29:48.331]                   options(future.plan = NULL)
[17:29:48.331]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.331]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:48.331]                 }
[17:29:48.331]                 ...future.workdir <- getwd()
[17:29:48.331]             }
[17:29:48.331]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:48.331]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:48.331]         }
[17:29:48.331]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:48.331]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:48.331]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:48.331]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:48.331]             future.rng.onMisuse = "warning", future.rng.onMisuse.keepFuture = NULL, 
[17:29:48.331]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:48.331]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:48.331]             base::names(...future.oldOptions))
[17:29:48.331]     }
[17:29:48.331]     if (FALSE) {
[17:29:48.331]     }
[17:29:48.331]     else {
[17:29:48.331]         if (TRUE) {
[17:29:48.331]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:48.331]                 open = "w")
[17:29:48.331]         }
[17:29:48.331]         else {
[17:29:48.331]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:48.331]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:48.331]         }
[17:29:48.331]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:48.331]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:48.331]             base::sink(type = "output", split = FALSE)
[17:29:48.331]             base::close(...future.stdout)
[17:29:48.331]         }, add = TRUE)
[17:29:48.331]     }
[17:29:48.331]     ...future.frame <- base::sys.nframe()
[17:29:48.331]     ...future.conditions <- base::list()
[17:29:48.331]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:48.331]     if (FALSE) {
[17:29:48.331]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:48.331]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:48.331]     }
[17:29:48.331]     ...future.result <- base::tryCatch({
[17:29:48.331]         base::withCallingHandlers({
[17:29:48.331]             ...future.value <- base::withVisible(base::local({
[17:29:48.331]                 ...future.makeSendCondition <- base::local({
[17:29:48.331]                   sendCondition <- NULL
[17:29:48.331]                   function(frame = 1L) {
[17:29:48.331]                     if (is.function(sendCondition)) 
[17:29:48.331]                       return(sendCondition)
[17:29:48.331]                     ns <- getNamespace("parallel")
[17:29:48.331]                     if (exists("sendData", mode = "function", 
[17:29:48.331]                       envir = ns)) {
[17:29:48.331]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:48.331]                         envir = ns)
[17:29:48.331]                       envir <- sys.frame(frame)
[17:29:48.331]                       master <- NULL
[17:29:48.331]                       while (!identical(envir, .GlobalEnv) && 
[17:29:48.331]                         !identical(envir, emptyenv())) {
[17:29:48.331]                         if (exists("master", mode = "list", envir = envir, 
[17:29:48.331]                           inherits = FALSE)) {
[17:29:48.331]                           master <- get("master", mode = "list", 
[17:29:48.331]                             envir = envir, inherits = FALSE)
[17:29:48.331]                           if (inherits(master, c("SOCKnode", 
[17:29:48.331]                             "SOCK0node"))) {
[17:29:48.331]                             sendCondition <<- function(cond) {
[17:29:48.331]                               data <- list(type = "VALUE", value = cond, 
[17:29:48.331]                                 success = TRUE)
[17:29:48.331]                               parallel_sendData(master, data)
[17:29:48.331]                             }
[17:29:48.331]                             return(sendCondition)
[17:29:48.331]                           }
[17:29:48.331]                         }
[17:29:48.331]                         frame <- frame + 1L
[17:29:48.331]                         envir <- sys.frame(frame)
[17:29:48.331]                       }
[17:29:48.331]                     }
[17:29:48.331]                     sendCondition <<- function(cond) NULL
[17:29:48.331]                   }
[17:29:48.331]                 })
[17:29:48.331]                 withCallingHandlers({
[17:29:48.331]                   {
[17:29:48.331]                     sample(x, size = 1L)
[17:29:48.331]                   }
[17:29:48.331]                 }, immediateCondition = function(cond) {
[17:29:48.331]                   sendCondition <- ...future.makeSendCondition()
[17:29:48.331]                   sendCondition(cond)
[17:29:48.331]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.331]                   {
[17:29:48.331]                     inherits <- base::inherits
[17:29:48.331]                     invokeRestart <- base::invokeRestart
[17:29:48.331]                     is.null <- base::is.null
[17:29:48.331]                     muffled <- FALSE
[17:29:48.331]                     if (inherits(cond, "message")) {
[17:29:48.331]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:48.331]                       if (muffled) 
[17:29:48.331]                         invokeRestart("muffleMessage")
[17:29:48.331]                     }
[17:29:48.331]                     else if (inherits(cond, "warning")) {
[17:29:48.331]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:48.331]                       if (muffled) 
[17:29:48.331]                         invokeRestart("muffleWarning")
[17:29:48.331]                     }
[17:29:48.331]                     else if (inherits(cond, "condition")) {
[17:29:48.331]                       if (!is.null(pattern)) {
[17:29:48.331]                         computeRestarts <- base::computeRestarts
[17:29:48.331]                         grepl <- base::grepl
[17:29:48.331]                         restarts <- computeRestarts(cond)
[17:29:48.331]                         for (restart in restarts) {
[17:29:48.331]                           name <- restart$name
[17:29:48.331]                           if (is.null(name)) 
[17:29:48.331]                             next
[17:29:48.331]                           if (!grepl(pattern, name)) 
[17:29:48.331]                             next
[17:29:48.331]                           invokeRestart(restart)
[17:29:48.331]                           muffled <- TRUE
[17:29:48.331]                           break
[17:29:48.331]                         }
[17:29:48.331]                       }
[17:29:48.331]                     }
[17:29:48.331]                     invisible(muffled)
[17:29:48.331]                   }
[17:29:48.331]                   muffleCondition(cond)
[17:29:48.331]                 })
[17:29:48.331]             }))
[17:29:48.331]             future::FutureResult(value = ...future.value$value, 
[17:29:48.331]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.331]                   ...future.rng), globalenv = if (FALSE) 
[17:29:48.331]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:48.331]                     ...future.globalenv.names))
[17:29:48.331]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:48.331]         }, condition = base::local({
[17:29:48.331]             c <- base::c
[17:29:48.331]             inherits <- base::inherits
[17:29:48.331]             invokeRestart <- base::invokeRestart
[17:29:48.331]             length <- base::length
[17:29:48.331]             list <- base::list
[17:29:48.331]             seq.int <- base::seq.int
[17:29:48.331]             signalCondition <- base::signalCondition
[17:29:48.331]             sys.calls <- base::sys.calls
[17:29:48.331]             `[[` <- base::`[[`
[17:29:48.331]             `+` <- base::`+`
[17:29:48.331]             `<<-` <- base::`<<-`
[17:29:48.331]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:48.331]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:48.331]                   3L)]
[17:29:48.331]             }
[17:29:48.331]             function(cond) {
[17:29:48.331]                 is_error <- inherits(cond, "error")
[17:29:48.331]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:48.331]                   NULL)
[17:29:48.331]                 if (is_error) {
[17:29:48.331]                   sessionInformation <- function() {
[17:29:48.331]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:48.331]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:48.331]                       search = base::search(), system = base::Sys.info())
[17:29:48.331]                   }
[17:29:48.331]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.331]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:48.331]                     cond$call), session = sessionInformation(), 
[17:29:48.331]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:48.331]                   signalCondition(cond)
[17:29:48.331]                 }
[17:29:48.331]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:48.331]                 "immediateCondition"))) {
[17:29:48.331]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:48.331]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.331]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:48.331]                   if (TRUE && !signal) {
[17:29:48.331]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.331]                     {
[17:29:48.331]                       inherits <- base::inherits
[17:29:48.331]                       invokeRestart <- base::invokeRestart
[17:29:48.331]                       is.null <- base::is.null
[17:29:48.331]                       muffled <- FALSE
[17:29:48.331]                       if (inherits(cond, "message")) {
[17:29:48.331]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.331]                         if (muffled) 
[17:29:48.331]                           invokeRestart("muffleMessage")
[17:29:48.331]                       }
[17:29:48.331]                       else if (inherits(cond, "warning")) {
[17:29:48.331]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.331]                         if (muffled) 
[17:29:48.331]                           invokeRestart("muffleWarning")
[17:29:48.331]                       }
[17:29:48.331]                       else if (inherits(cond, "condition")) {
[17:29:48.331]                         if (!is.null(pattern)) {
[17:29:48.331]                           computeRestarts <- base::computeRestarts
[17:29:48.331]                           grepl <- base::grepl
[17:29:48.331]                           restarts <- computeRestarts(cond)
[17:29:48.331]                           for (restart in restarts) {
[17:29:48.331]                             name <- restart$name
[17:29:48.331]                             if (is.null(name)) 
[17:29:48.331]                               next
[17:29:48.331]                             if (!grepl(pattern, name)) 
[17:29:48.331]                               next
[17:29:48.331]                             invokeRestart(restart)
[17:29:48.331]                             muffled <- TRUE
[17:29:48.331]                             break
[17:29:48.331]                           }
[17:29:48.331]                         }
[17:29:48.331]                       }
[17:29:48.331]                       invisible(muffled)
[17:29:48.331]                     }
[17:29:48.331]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.331]                   }
[17:29:48.331]                 }
[17:29:48.331]                 else {
[17:29:48.331]                   if (TRUE) {
[17:29:48.331]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.331]                     {
[17:29:48.331]                       inherits <- base::inherits
[17:29:48.331]                       invokeRestart <- base::invokeRestart
[17:29:48.331]                       is.null <- base::is.null
[17:29:48.331]                       muffled <- FALSE
[17:29:48.331]                       if (inherits(cond, "message")) {
[17:29:48.331]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.331]                         if (muffled) 
[17:29:48.331]                           invokeRestart("muffleMessage")
[17:29:48.331]                       }
[17:29:48.331]                       else if (inherits(cond, "warning")) {
[17:29:48.331]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.331]                         if (muffled) 
[17:29:48.331]                           invokeRestart("muffleWarning")
[17:29:48.331]                       }
[17:29:48.331]                       else if (inherits(cond, "condition")) {
[17:29:48.331]                         if (!is.null(pattern)) {
[17:29:48.331]                           computeRestarts <- base::computeRestarts
[17:29:48.331]                           grepl <- base::grepl
[17:29:48.331]                           restarts <- computeRestarts(cond)
[17:29:48.331]                           for (restart in restarts) {
[17:29:48.331]                             name <- restart$name
[17:29:48.331]                             if (is.null(name)) 
[17:29:48.331]                               next
[17:29:48.331]                             if (!grepl(pattern, name)) 
[17:29:48.331]                               next
[17:29:48.331]                             invokeRestart(restart)
[17:29:48.331]                             muffled <- TRUE
[17:29:48.331]                             break
[17:29:48.331]                           }
[17:29:48.331]                         }
[17:29:48.331]                       }
[17:29:48.331]                       invisible(muffled)
[17:29:48.331]                     }
[17:29:48.331]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.331]                   }
[17:29:48.331]                 }
[17:29:48.331]             }
[17:29:48.331]         }))
[17:29:48.331]     }, error = function(ex) {
[17:29:48.331]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:48.331]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.331]                 ...future.rng), started = ...future.startTime, 
[17:29:48.331]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:48.331]             version = "1.8"), class = "FutureResult")
[17:29:48.331]     }, finally = {
[17:29:48.331]         if (!identical(...future.workdir, getwd())) 
[17:29:48.331]             setwd(...future.workdir)
[17:29:48.331]         {
[17:29:48.331]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:48.331]                 ...future.oldOptions$nwarnings <- NULL
[17:29:48.331]             }
[17:29:48.331]             base::options(...future.oldOptions)
[17:29:48.331]             if (.Platform$OS.type == "windows") {
[17:29:48.331]                 old_names <- names(...future.oldEnvVars)
[17:29:48.331]                 envs <- base::Sys.getenv()
[17:29:48.331]                 names <- names(envs)
[17:29:48.331]                 common <- intersect(names, old_names)
[17:29:48.331]                 added <- setdiff(names, old_names)
[17:29:48.331]                 removed <- setdiff(old_names, names)
[17:29:48.331]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:48.331]                   envs[common]]
[17:29:48.331]                 NAMES <- toupper(changed)
[17:29:48.331]                 args <- list()
[17:29:48.331]                 for (kk in seq_along(NAMES)) {
[17:29:48.331]                   name <- changed[[kk]]
[17:29:48.331]                   NAME <- NAMES[[kk]]
[17:29:48.331]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.331]                     next
[17:29:48.331]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.331]                 }
[17:29:48.331]                 NAMES <- toupper(added)
[17:29:48.331]                 for (kk in seq_along(NAMES)) {
[17:29:48.331]                   name <- added[[kk]]
[17:29:48.331]                   NAME <- NAMES[[kk]]
[17:29:48.331]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.331]                     next
[17:29:48.331]                   args[[name]] <- ""
[17:29:48.331]                 }
[17:29:48.331]                 NAMES <- toupper(removed)
[17:29:48.331]                 for (kk in seq_along(NAMES)) {
[17:29:48.331]                   name <- removed[[kk]]
[17:29:48.331]                   NAME <- NAMES[[kk]]
[17:29:48.331]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.331]                     next
[17:29:48.331]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.331]                 }
[17:29:48.331]                 if (length(args) > 0) 
[17:29:48.331]                   base::do.call(base::Sys.setenv, args = args)
[17:29:48.331]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:48.331]             }
[17:29:48.331]             else {
[17:29:48.331]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:48.331]             }
[17:29:48.331]             {
[17:29:48.331]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:48.331]                   0L) {
[17:29:48.331]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:48.331]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:48.331]                   base::options(opts)
[17:29:48.331]                 }
[17:29:48.331]                 {
[17:29:48.331]                   {
[17:29:48.331]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:48.331]                     NULL
[17:29:48.331]                   }
[17:29:48.331]                   options(future.plan = NULL)
[17:29:48.331]                   if (is.na(NA_character_)) 
[17:29:48.331]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.331]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:48.331]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:48.331]                     .init = FALSE)
[17:29:48.331]                 }
[17:29:48.331]             }
[17:29:48.331]         }
[17:29:48.331]     })
[17:29:48.331]     if (TRUE) {
[17:29:48.331]         base::sink(type = "output", split = FALSE)
[17:29:48.331]         if (TRUE) {
[17:29:48.331]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:48.331]         }
[17:29:48.331]         else {
[17:29:48.331]             ...future.result["stdout"] <- base::list(NULL)
[17:29:48.331]         }
[17:29:48.331]         base::close(...future.stdout)
[17:29:48.331]         ...future.stdout <- NULL
[17:29:48.331]     }
[17:29:48.331]     ...future.result$conditions <- ...future.conditions
[17:29:48.331]     ...future.result$finished <- base::Sys.time()
[17:29:48.331]     ...future.result
[17:29:48.331] }
[17:29:48.338] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:48.364] receiveMessageFromWorker() for ClusterFuture ...
[17:29:48.364] - Validating connection of MultisessionFuture
[17:29:48.365] - received message: FutureResult
[17:29:48.365] - Received FutureResult
[17:29:48.365] - Erased future from FutureRegistry
[17:29:48.366] result() for ClusterFuture ...
[17:29:48.366] - result already collected: FutureResult
[17:29:48.366] result() for ClusterFuture ... done
[17:29:48.366] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:48.367] result() for ClusterFuture ...
[17:29:48.367] - result already collected: FutureResult
[17:29:48.367] result() for ClusterFuture ... done
[17:29:48.368] result() for ClusterFuture ...
[17:29:48.368] - result already collected: FutureResult
[17:29:48.368] result() for ClusterFuture ... done
[17:29:48.370] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:48.370] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:48.371] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:48.371] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:48.372] MultisessionFuture started
[17:29:48.372] - Launch lazy future ... done
[17:29:48.373] run() for 'MultisessionFuture' ... done
[17:29:48.373] result() for ClusterFuture ...
[17:29:48.373] - result already collected: FutureResult
[17:29:48.374] result() for ClusterFuture ... done
[17:29:48.374] result() for ClusterFuture ...
[17:29:48.374] - result already collected: FutureResult
[17:29:48.374] result() for ClusterFuture ... done
[17:29:48.375] result() for ClusterFuture ...
[17:29:48.375] - result already collected: FutureResult
[17:29:48.375] result() for ClusterFuture ... done
[17:29:48.376] result() for ClusterFuture ...
[17:29:48.376] - result already collected: FutureResult
[17:29:48.376] result() for ClusterFuture ... done
[17:29:48.377] result() for ClusterFuture ...
[17:29:48.377] receiveMessageFromWorker() for ClusterFuture ...
[17:29:48.377] - Validating connection of MultisessionFuture
[17:29:48.378] - received message: FutureResult
[17:29:48.378] - Received FutureResult
[17:29:48.378] - Erased future from FutureRegistry
[17:29:48.378] result() for ClusterFuture ...
[17:29:48.379] - result already collected: FutureResult
[17:29:48.379] result() for ClusterFuture ... done
[17:29:48.379] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:48.380] result() for ClusterFuture ... done
[17:29:48.380] result() for ClusterFuture ...
[17:29:48.380] - result already collected: FutureResult
[17:29:48.380] result() for ClusterFuture ... done
[17:29:48.381] result() for ClusterFuture ...
[17:29:48.381] receiveMessageFromWorker() for ClusterFuture ...
[17:29:48.381] - Validating connection of MultisessionFuture
[17:29:48.409] - received message: FutureResult
[17:29:48.410] - Received FutureResult
[17:29:48.410] - Erased future from FutureRegistry
[17:29:48.410] result() for ClusterFuture ...
[17:29:48.410] - result already collected: FutureResult
[17:29:48.411] result() for ClusterFuture ... done
[17:29:48.411] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:48.411] result() for ClusterFuture ... done
[17:29:48.411] result() for ClusterFuture ...
[17:29:48.412] - result already collected: FutureResult
[17:29:48.412] result() for ClusterFuture ... done
[[1]]
[1] 2

[[2]]
[1] 3

[[3]]
[1] 1

[[4]]
[1] 3

[17:29:48.413] getGlobalsAndPackages() ...
[17:29:48.414] Searching for globals...
[17:29:48.416] - globals found: [3] '{', 'sample', 'x'
[17:29:48.416] Searching for globals ... DONE
[17:29:48.416] Resolving globals: FALSE
[17:29:48.417] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:48.418] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:48.418] - globals: [1] 'x'
[17:29:48.418] 
[17:29:48.418] getGlobalsAndPackages() ... DONE
[17:29:48.419] run() for 'Future' ...
[17:29:48.419] - state: 'created'
[17:29:48.420] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:48.439] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:48.439] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:48.440]   - Field: 'node'
[17:29:48.440]   - Field: 'label'
[17:29:48.440]   - Field: 'local'
[17:29:48.441]   - Field: 'owner'
[17:29:48.441]   - Field: 'envir'
[17:29:48.441]   - Field: 'workers'
[17:29:48.441]   - Field: 'packages'
[17:29:48.442]   - Field: 'gc'
[17:29:48.442]   - Field: 'conditions'
[17:29:48.442]   - Field: 'persistent'
[17:29:48.442]   - Field: 'expr'
[17:29:48.443]   - Field: 'uuid'
[17:29:48.443]   - Field: 'seed'
[17:29:48.443]   - Field: 'version'
[17:29:48.444]   - Field: 'result'
[17:29:48.444]   - Field: 'asynchronous'
[17:29:48.444]   - Field: 'calls'
[17:29:48.444]   - Field: 'globals'
[17:29:48.445]   - Field: 'stdout'
[17:29:48.445]   - Field: 'earlySignal'
[17:29:48.445]   - Field: 'lazy'
[17:29:48.445]   - Field: 'state'
[17:29:48.446] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:48.446] - Launch lazy future ...
[17:29:48.446] Packages needed by the future expression (n = 0): <none>
[17:29:48.447] Packages needed by future strategies (n = 0): <none>
[17:29:48.447] {
[17:29:48.447]     {
[17:29:48.447]         {
[17:29:48.447]             ...future.startTime <- base::Sys.time()
[17:29:48.447]             {
[17:29:48.447]                 {
[17:29:48.447]                   {
[17:29:48.447]                     {
[17:29:48.447]                       base::local({
[17:29:48.447]                         has_future <- base::requireNamespace("future", 
[17:29:48.447]                           quietly = TRUE)
[17:29:48.447]                         if (has_future) {
[17:29:48.447]                           ns <- base::getNamespace("future")
[17:29:48.447]                           version <- ns[[".package"]][["version"]]
[17:29:48.447]                           if (is.null(version)) 
[17:29:48.447]                             version <- utils::packageVersion("future")
[17:29:48.447]                         }
[17:29:48.447]                         else {
[17:29:48.447]                           version <- NULL
[17:29:48.447]                         }
[17:29:48.447]                         if (!has_future || version < "1.8.0") {
[17:29:48.447]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:48.447]                             "", base::R.version$version.string), 
[17:29:48.447]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:48.447]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:48.447]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:48.447]                               "release", "version")], collapse = " "), 
[17:29:48.447]                             hostname = base::Sys.info()[["nodename"]])
[17:29:48.447]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:48.447]                             info)
[17:29:48.447]                           info <- base::paste(info, collapse = "; ")
[17:29:48.447]                           if (!has_future) {
[17:29:48.447]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:48.447]                               info)
[17:29:48.447]                           }
[17:29:48.447]                           else {
[17:29:48.447]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:48.447]                               info, version)
[17:29:48.447]                           }
[17:29:48.447]                           base::stop(msg)
[17:29:48.447]                         }
[17:29:48.447]                       })
[17:29:48.447]                     }
[17:29:48.447]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:48.447]                     base::options(mc.cores = 1L)
[17:29:48.447]                   }
[17:29:48.447]                   ...future.strategy.old <- future::plan("list")
[17:29:48.447]                   options(future.plan = NULL)
[17:29:48.447]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.447]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:48.447]                 }
[17:29:48.447]                 ...future.workdir <- getwd()
[17:29:48.447]             }
[17:29:48.447]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:48.447]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:48.447]         }
[17:29:48.447]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:48.447]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:48.447]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:48.447]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:48.447]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:48.447]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:48.447]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:48.447]             base::names(...future.oldOptions))
[17:29:48.447]     }
[17:29:48.447]     if (FALSE) {
[17:29:48.447]     }
[17:29:48.447]     else {
[17:29:48.447]         if (TRUE) {
[17:29:48.447]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:48.447]                 open = "w")
[17:29:48.447]         }
[17:29:48.447]         else {
[17:29:48.447]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:48.447]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:48.447]         }
[17:29:48.447]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:48.447]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:48.447]             base::sink(type = "output", split = FALSE)
[17:29:48.447]             base::close(...future.stdout)
[17:29:48.447]         }, add = TRUE)
[17:29:48.447]     }
[17:29:48.447]     ...future.frame <- base::sys.nframe()
[17:29:48.447]     ...future.conditions <- base::list()
[17:29:48.447]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:48.447]     if (FALSE) {
[17:29:48.447]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:48.447]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:48.447]     }
[17:29:48.447]     ...future.result <- base::tryCatch({
[17:29:48.447]         base::withCallingHandlers({
[17:29:48.447]             ...future.value <- base::withVisible(base::local({
[17:29:48.447]                 ...future.makeSendCondition <- base::local({
[17:29:48.447]                   sendCondition <- NULL
[17:29:48.447]                   function(frame = 1L) {
[17:29:48.447]                     if (is.function(sendCondition)) 
[17:29:48.447]                       return(sendCondition)
[17:29:48.447]                     ns <- getNamespace("parallel")
[17:29:48.447]                     if (exists("sendData", mode = "function", 
[17:29:48.447]                       envir = ns)) {
[17:29:48.447]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:48.447]                         envir = ns)
[17:29:48.447]                       envir <- sys.frame(frame)
[17:29:48.447]                       master <- NULL
[17:29:48.447]                       while (!identical(envir, .GlobalEnv) && 
[17:29:48.447]                         !identical(envir, emptyenv())) {
[17:29:48.447]                         if (exists("master", mode = "list", envir = envir, 
[17:29:48.447]                           inherits = FALSE)) {
[17:29:48.447]                           master <- get("master", mode = "list", 
[17:29:48.447]                             envir = envir, inherits = FALSE)
[17:29:48.447]                           if (inherits(master, c("SOCKnode", 
[17:29:48.447]                             "SOCK0node"))) {
[17:29:48.447]                             sendCondition <<- function(cond) {
[17:29:48.447]                               data <- list(type = "VALUE", value = cond, 
[17:29:48.447]                                 success = TRUE)
[17:29:48.447]                               parallel_sendData(master, data)
[17:29:48.447]                             }
[17:29:48.447]                             return(sendCondition)
[17:29:48.447]                           }
[17:29:48.447]                         }
[17:29:48.447]                         frame <- frame + 1L
[17:29:48.447]                         envir <- sys.frame(frame)
[17:29:48.447]                       }
[17:29:48.447]                     }
[17:29:48.447]                     sendCondition <<- function(cond) NULL
[17:29:48.447]                   }
[17:29:48.447]                 })
[17:29:48.447]                 withCallingHandlers({
[17:29:48.447]                   {
[17:29:48.447]                     sample(x, size = 1L)
[17:29:48.447]                   }
[17:29:48.447]                 }, immediateCondition = function(cond) {
[17:29:48.447]                   sendCondition <- ...future.makeSendCondition()
[17:29:48.447]                   sendCondition(cond)
[17:29:48.447]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.447]                   {
[17:29:48.447]                     inherits <- base::inherits
[17:29:48.447]                     invokeRestart <- base::invokeRestart
[17:29:48.447]                     is.null <- base::is.null
[17:29:48.447]                     muffled <- FALSE
[17:29:48.447]                     if (inherits(cond, "message")) {
[17:29:48.447]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:48.447]                       if (muffled) 
[17:29:48.447]                         invokeRestart("muffleMessage")
[17:29:48.447]                     }
[17:29:48.447]                     else if (inherits(cond, "warning")) {
[17:29:48.447]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:48.447]                       if (muffled) 
[17:29:48.447]                         invokeRestart("muffleWarning")
[17:29:48.447]                     }
[17:29:48.447]                     else if (inherits(cond, "condition")) {
[17:29:48.447]                       if (!is.null(pattern)) {
[17:29:48.447]                         computeRestarts <- base::computeRestarts
[17:29:48.447]                         grepl <- base::grepl
[17:29:48.447]                         restarts <- computeRestarts(cond)
[17:29:48.447]                         for (restart in restarts) {
[17:29:48.447]                           name <- restart$name
[17:29:48.447]                           if (is.null(name)) 
[17:29:48.447]                             next
[17:29:48.447]                           if (!grepl(pattern, name)) 
[17:29:48.447]                             next
[17:29:48.447]                           invokeRestart(restart)
[17:29:48.447]                           muffled <- TRUE
[17:29:48.447]                           break
[17:29:48.447]                         }
[17:29:48.447]                       }
[17:29:48.447]                     }
[17:29:48.447]                     invisible(muffled)
[17:29:48.447]                   }
[17:29:48.447]                   muffleCondition(cond)
[17:29:48.447]                 })
[17:29:48.447]             }))
[17:29:48.447]             future::FutureResult(value = ...future.value$value, 
[17:29:48.447]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.447]                   ...future.rng), globalenv = if (FALSE) 
[17:29:48.447]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:48.447]                     ...future.globalenv.names))
[17:29:48.447]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:48.447]         }, condition = base::local({
[17:29:48.447]             c <- base::c
[17:29:48.447]             inherits <- base::inherits
[17:29:48.447]             invokeRestart <- base::invokeRestart
[17:29:48.447]             length <- base::length
[17:29:48.447]             list <- base::list
[17:29:48.447]             seq.int <- base::seq.int
[17:29:48.447]             signalCondition <- base::signalCondition
[17:29:48.447]             sys.calls <- base::sys.calls
[17:29:48.447]             `[[` <- base::`[[`
[17:29:48.447]             `+` <- base::`+`
[17:29:48.447]             `<<-` <- base::`<<-`
[17:29:48.447]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:48.447]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:48.447]                   3L)]
[17:29:48.447]             }
[17:29:48.447]             function(cond) {
[17:29:48.447]                 is_error <- inherits(cond, "error")
[17:29:48.447]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:48.447]                   NULL)
[17:29:48.447]                 if (is_error) {
[17:29:48.447]                   sessionInformation <- function() {
[17:29:48.447]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:48.447]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:48.447]                       search = base::search(), system = base::Sys.info())
[17:29:48.447]                   }
[17:29:48.447]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.447]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:48.447]                     cond$call), session = sessionInformation(), 
[17:29:48.447]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:48.447]                   signalCondition(cond)
[17:29:48.447]                 }
[17:29:48.447]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:48.447]                 "immediateCondition"))) {
[17:29:48.447]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:48.447]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.447]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:48.447]                   if (TRUE && !signal) {
[17:29:48.447]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.447]                     {
[17:29:48.447]                       inherits <- base::inherits
[17:29:48.447]                       invokeRestart <- base::invokeRestart
[17:29:48.447]                       is.null <- base::is.null
[17:29:48.447]                       muffled <- FALSE
[17:29:48.447]                       if (inherits(cond, "message")) {
[17:29:48.447]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.447]                         if (muffled) 
[17:29:48.447]                           invokeRestart("muffleMessage")
[17:29:48.447]                       }
[17:29:48.447]                       else if (inherits(cond, "warning")) {
[17:29:48.447]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.447]                         if (muffled) 
[17:29:48.447]                           invokeRestart("muffleWarning")
[17:29:48.447]                       }
[17:29:48.447]                       else if (inherits(cond, "condition")) {
[17:29:48.447]                         if (!is.null(pattern)) {
[17:29:48.447]                           computeRestarts <- base::computeRestarts
[17:29:48.447]                           grepl <- base::grepl
[17:29:48.447]                           restarts <- computeRestarts(cond)
[17:29:48.447]                           for (restart in restarts) {
[17:29:48.447]                             name <- restart$name
[17:29:48.447]                             if (is.null(name)) 
[17:29:48.447]                               next
[17:29:48.447]                             if (!grepl(pattern, name)) 
[17:29:48.447]                               next
[17:29:48.447]                             invokeRestart(restart)
[17:29:48.447]                             muffled <- TRUE
[17:29:48.447]                             break
[17:29:48.447]                           }
[17:29:48.447]                         }
[17:29:48.447]                       }
[17:29:48.447]                       invisible(muffled)
[17:29:48.447]                     }
[17:29:48.447]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.447]                   }
[17:29:48.447]                 }
[17:29:48.447]                 else {
[17:29:48.447]                   if (TRUE) {
[17:29:48.447]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.447]                     {
[17:29:48.447]                       inherits <- base::inherits
[17:29:48.447]                       invokeRestart <- base::invokeRestart
[17:29:48.447]                       is.null <- base::is.null
[17:29:48.447]                       muffled <- FALSE
[17:29:48.447]                       if (inherits(cond, "message")) {
[17:29:48.447]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.447]                         if (muffled) 
[17:29:48.447]                           invokeRestart("muffleMessage")
[17:29:48.447]                       }
[17:29:48.447]                       else if (inherits(cond, "warning")) {
[17:29:48.447]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.447]                         if (muffled) 
[17:29:48.447]                           invokeRestart("muffleWarning")
[17:29:48.447]                       }
[17:29:48.447]                       else if (inherits(cond, "condition")) {
[17:29:48.447]                         if (!is.null(pattern)) {
[17:29:48.447]                           computeRestarts <- base::computeRestarts
[17:29:48.447]                           grepl <- base::grepl
[17:29:48.447]                           restarts <- computeRestarts(cond)
[17:29:48.447]                           for (restart in restarts) {
[17:29:48.447]                             name <- restart$name
[17:29:48.447]                             if (is.null(name)) 
[17:29:48.447]                               next
[17:29:48.447]                             if (!grepl(pattern, name)) 
[17:29:48.447]                               next
[17:29:48.447]                             invokeRestart(restart)
[17:29:48.447]                             muffled <- TRUE
[17:29:48.447]                             break
[17:29:48.447]                           }
[17:29:48.447]                         }
[17:29:48.447]                       }
[17:29:48.447]                       invisible(muffled)
[17:29:48.447]                     }
[17:29:48.447]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.447]                   }
[17:29:48.447]                 }
[17:29:48.447]             }
[17:29:48.447]         }))
[17:29:48.447]     }, error = function(ex) {
[17:29:48.447]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:48.447]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.447]                 ...future.rng), started = ...future.startTime, 
[17:29:48.447]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:48.447]             version = "1.8"), class = "FutureResult")
[17:29:48.447]     }, finally = {
[17:29:48.447]         if (!identical(...future.workdir, getwd())) 
[17:29:48.447]             setwd(...future.workdir)
[17:29:48.447]         {
[17:29:48.447]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:48.447]                 ...future.oldOptions$nwarnings <- NULL
[17:29:48.447]             }
[17:29:48.447]             base::options(...future.oldOptions)
[17:29:48.447]             if (.Platform$OS.type == "windows") {
[17:29:48.447]                 old_names <- names(...future.oldEnvVars)
[17:29:48.447]                 envs <- base::Sys.getenv()
[17:29:48.447]                 names <- names(envs)
[17:29:48.447]                 common <- intersect(names, old_names)
[17:29:48.447]                 added <- setdiff(names, old_names)
[17:29:48.447]                 removed <- setdiff(old_names, names)
[17:29:48.447]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:48.447]                   envs[common]]
[17:29:48.447]                 NAMES <- toupper(changed)
[17:29:48.447]                 args <- list()
[17:29:48.447]                 for (kk in seq_along(NAMES)) {
[17:29:48.447]                   name <- changed[[kk]]
[17:29:48.447]                   NAME <- NAMES[[kk]]
[17:29:48.447]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.447]                     next
[17:29:48.447]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.447]                 }
[17:29:48.447]                 NAMES <- toupper(added)
[17:29:48.447]                 for (kk in seq_along(NAMES)) {
[17:29:48.447]                   name <- added[[kk]]
[17:29:48.447]                   NAME <- NAMES[[kk]]
[17:29:48.447]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.447]                     next
[17:29:48.447]                   args[[name]] <- ""
[17:29:48.447]                 }
[17:29:48.447]                 NAMES <- toupper(removed)
[17:29:48.447]                 for (kk in seq_along(NAMES)) {
[17:29:48.447]                   name <- removed[[kk]]
[17:29:48.447]                   NAME <- NAMES[[kk]]
[17:29:48.447]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.447]                     next
[17:29:48.447]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.447]                 }
[17:29:48.447]                 if (length(args) > 0) 
[17:29:48.447]                   base::do.call(base::Sys.setenv, args = args)
[17:29:48.447]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:48.447]             }
[17:29:48.447]             else {
[17:29:48.447]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:48.447]             }
[17:29:48.447]             {
[17:29:48.447]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:48.447]                   0L) {
[17:29:48.447]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:48.447]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:48.447]                   base::options(opts)
[17:29:48.447]                 }
[17:29:48.447]                 {
[17:29:48.447]                   {
[17:29:48.447]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:48.447]                     NULL
[17:29:48.447]                   }
[17:29:48.447]                   options(future.plan = NULL)
[17:29:48.447]                   if (is.na(NA_character_)) 
[17:29:48.447]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.447]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:48.447]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:48.447]                     .init = FALSE)
[17:29:48.447]                 }
[17:29:48.447]             }
[17:29:48.447]         }
[17:29:48.447]     })
[17:29:48.447]     if (TRUE) {
[17:29:48.447]         base::sink(type = "output", split = FALSE)
[17:29:48.447]         if (TRUE) {
[17:29:48.447]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:48.447]         }
[17:29:48.447]         else {
[17:29:48.447]             ...future.result["stdout"] <- base::list(NULL)
[17:29:48.447]         }
[17:29:48.447]         base::close(...future.stdout)
[17:29:48.447]         ...future.stdout <- NULL
[17:29:48.447]     }
[17:29:48.447]     ...future.result$conditions <- ...future.conditions
[17:29:48.447]     ...future.result$finished <- base::Sys.time()
[17:29:48.447]     ...future.result
[17:29:48.447] }
[17:29:48.456] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:48.456] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:48.457] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:48.457] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:48.458] MultisessionFuture started
[17:29:48.458] - Launch lazy future ... done
[17:29:48.459] run() for 'MultisessionFuture' ... done
[17:29:48.460] getGlobalsAndPackages() ...
[17:29:48.460] Searching for globals...
[17:29:48.462] - globals found: [3] '{', 'sample', 'x'
[17:29:48.462] Searching for globals ... DONE
[17:29:48.462] Resolving globals: FALSE
[17:29:48.463] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:48.464] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:48.464] - globals: [1] 'x'
[17:29:48.464] 
[17:29:48.464] getGlobalsAndPackages() ... DONE
[17:29:48.465] run() for 'Future' ...
[17:29:48.465] - state: 'created'
[17:29:48.465] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:48.482] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:48.482] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:48.482]   - Field: 'node'
[17:29:48.482]   - Field: 'label'
[17:29:48.483]   - Field: 'local'
[17:29:48.483]   - Field: 'owner'
[17:29:48.483]   - Field: 'envir'
[17:29:48.483]   - Field: 'workers'
[17:29:48.484]   - Field: 'packages'
[17:29:48.484]   - Field: 'gc'
[17:29:48.484]   - Field: 'conditions'
[17:29:48.484]   - Field: 'persistent'
[17:29:48.485]   - Field: 'expr'
[17:29:48.485]   - Field: 'uuid'
[17:29:48.485]   - Field: 'seed'
[17:29:48.485]   - Field: 'version'
[17:29:48.486]   - Field: 'result'
[17:29:48.486]   - Field: 'asynchronous'
[17:29:48.486]   - Field: 'calls'
[17:29:48.486]   - Field: 'globals'
[17:29:48.487]   - Field: 'stdout'
[17:29:48.487]   - Field: 'earlySignal'
[17:29:48.487]   - Field: 'lazy'
[17:29:48.488]   - Field: 'state'
[17:29:48.488] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:48.488] - Launch lazy future ...
[17:29:48.489] Packages needed by the future expression (n = 0): <none>
[17:29:48.489] Packages needed by future strategies (n = 0): <none>
[17:29:48.490] {
[17:29:48.490]     {
[17:29:48.490]         {
[17:29:48.490]             ...future.startTime <- base::Sys.time()
[17:29:48.490]             {
[17:29:48.490]                 {
[17:29:48.490]                   {
[17:29:48.490]                     {
[17:29:48.490]                       base::local({
[17:29:48.490]                         has_future <- base::requireNamespace("future", 
[17:29:48.490]                           quietly = TRUE)
[17:29:48.490]                         if (has_future) {
[17:29:48.490]                           ns <- base::getNamespace("future")
[17:29:48.490]                           version <- ns[[".package"]][["version"]]
[17:29:48.490]                           if (is.null(version)) 
[17:29:48.490]                             version <- utils::packageVersion("future")
[17:29:48.490]                         }
[17:29:48.490]                         else {
[17:29:48.490]                           version <- NULL
[17:29:48.490]                         }
[17:29:48.490]                         if (!has_future || version < "1.8.0") {
[17:29:48.490]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:48.490]                             "", base::R.version$version.string), 
[17:29:48.490]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:48.490]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:48.490]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:48.490]                               "release", "version")], collapse = " "), 
[17:29:48.490]                             hostname = base::Sys.info()[["nodename"]])
[17:29:48.490]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:48.490]                             info)
[17:29:48.490]                           info <- base::paste(info, collapse = "; ")
[17:29:48.490]                           if (!has_future) {
[17:29:48.490]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:48.490]                               info)
[17:29:48.490]                           }
[17:29:48.490]                           else {
[17:29:48.490]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:48.490]                               info, version)
[17:29:48.490]                           }
[17:29:48.490]                           base::stop(msg)
[17:29:48.490]                         }
[17:29:48.490]                       })
[17:29:48.490]                     }
[17:29:48.490]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:48.490]                     base::options(mc.cores = 1L)
[17:29:48.490]                   }
[17:29:48.490]                   ...future.strategy.old <- future::plan("list")
[17:29:48.490]                   options(future.plan = NULL)
[17:29:48.490]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.490]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:48.490]                 }
[17:29:48.490]                 ...future.workdir <- getwd()
[17:29:48.490]             }
[17:29:48.490]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:48.490]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:48.490]         }
[17:29:48.490]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:48.490]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:48.490]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:48.490]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:48.490]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:48.490]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:48.490]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:48.490]             base::names(...future.oldOptions))
[17:29:48.490]     }
[17:29:48.490]     if (FALSE) {
[17:29:48.490]     }
[17:29:48.490]     else {
[17:29:48.490]         if (TRUE) {
[17:29:48.490]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:48.490]                 open = "w")
[17:29:48.490]         }
[17:29:48.490]         else {
[17:29:48.490]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:48.490]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:48.490]         }
[17:29:48.490]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:48.490]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:48.490]             base::sink(type = "output", split = FALSE)
[17:29:48.490]             base::close(...future.stdout)
[17:29:48.490]         }, add = TRUE)
[17:29:48.490]     }
[17:29:48.490]     ...future.frame <- base::sys.nframe()
[17:29:48.490]     ...future.conditions <- base::list()
[17:29:48.490]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:48.490]     if (FALSE) {
[17:29:48.490]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:48.490]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:48.490]     }
[17:29:48.490]     ...future.result <- base::tryCatch({
[17:29:48.490]         base::withCallingHandlers({
[17:29:48.490]             ...future.value <- base::withVisible(base::local({
[17:29:48.490]                 ...future.makeSendCondition <- base::local({
[17:29:48.490]                   sendCondition <- NULL
[17:29:48.490]                   function(frame = 1L) {
[17:29:48.490]                     if (is.function(sendCondition)) 
[17:29:48.490]                       return(sendCondition)
[17:29:48.490]                     ns <- getNamespace("parallel")
[17:29:48.490]                     if (exists("sendData", mode = "function", 
[17:29:48.490]                       envir = ns)) {
[17:29:48.490]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:48.490]                         envir = ns)
[17:29:48.490]                       envir <- sys.frame(frame)
[17:29:48.490]                       master <- NULL
[17:29:48.490]                       while (!identical(envir, .GlobalEnv) && 
[17:29:48.490]                         !identical(envir, emptyenv())) {
[17:29:48.490]                         if (exists("master", mode = "list", envir = envir, 
[17:29:48.490]                           inherits = FALSE)) {
[17:29:48.490]                           master <- get("master", mode = "list", 
[17:29:48.490]                             envir = envir, inherits = FALSE)
[17:29:48.490]                           if (inherits(master, c("SOCKnode", 
[17:29:48.490]                             "SOCK0node"))) {
[17:29:48.490]                             sendCondition <<- function(cond) {
[17:29:48.490]                               data <- list(type = "VALUE", value = cond, 
[17:29:48.490]                                 success = TRUE)
[17:29:48.490]                               parallel_sendData(master, data)
[17:29:48.490]                             }
[17:29:48.490]                             return(sendCondition)
[17:29:48.490]                           }
[17:29:48.490]                         }
[17:29:48.490]                         frame <- frame + 1L
[17:29:48.490]                         envir <- sys.frame(frame)
[17:29:48.490]                       }
[17:29:48.490]                     }
[17:29:48.490]                     sendCondition <<- function(cond) NULL
[17:29:48.490]                   }
[17:29:48.490]                 })
[17:29:48.490]                 withCallingHandlers({
[17:29:48.490]                   {
[17:29:48.490]                     sample(x, size = 1L)
[17:29:48.490]                   }
[17:29:48.490]                 }, immediateCondition = function(cond) {
[17:29:48.490]                   sendCondition <- ...future.makeSendCondition()
[17:29:48.490]                   sendCondition(cond)
[17:29:48.490]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.490]                   {
[17:29:48.490]                     inherits <- base::inherits
[17:29:48.490]                     invokeRestart <- base::invokeRestart
[17:29:48.490]                     is.null <- base::is.null
[17:29:48.490]                     muffled <- FALSE
[17:29:48.490]                     if (inherits(cond, "message")) {
[17:29:48.490]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:48.490]                       if (muffled) 
[17:29:48.490]                         invokeRestart("muffleMessage")
[17:29:48.490]                     }
[17:29:48.490]                     else if (inherits(cond, "warning")) {
[17:29:48.490]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:48.490]                       if (muffled) 
[17:29:48.490]                         invokeRestart("muffleWarning")
[17:29:48.490]                     }
[17:29:48.490]                     else if (inherits(cond, "condition")) {
[17:29:48.490]                       if (!is.null(pattern)) {
[17:29:48.490]                         computeRestarts <- base::computeRestarts
[17:29:48.490]                         grepl <- base::grepl
[17:29:48.490]                         restarts <- computeRestarts(cond)
[17:29:48.490]                         for (restart in restarts) {
[17:29:48.490]                           name <- restart$name
[17:29:48.490]                           if (is.null(name)) 
[17:29:48.490]                             next
[17:29:48.490]                           if (!grepl(pattern, name)) 
[17:29:48.490]                             next
[17:29:48.490]                           invokeRestart(restart)
[17:29:48.490]                           muffled <- TRUE
[17:29:48.490]                           break
[17:29:48.490]                         }
[17:29:48.490]                       }
[17:29:48.490]                     }
[17:29:48.490]                     invisible(muffled)
[17:29:48.490]                   }
[17:29:48.490]                   muffleCondition(cond)
[17:29:48.490]                 })
[17:29:48.490]             }))
[17:29:48.490]             future::FutureResult(value = ...future.value$value, 
[17:29:48.490]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.490]                   ...future.rng), globalenv = if (FALSE) 
[17:29:48.490]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:48.490]                     ...future.globalenv.names))
[17:29:48.490]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:48.490]         }, condition = base::local({
[17:29:48.490]             c <- base::c
[17:29:48.490]             inherits <- base::inherits
[17:29:48.490]             invokeRestart <- base::invokeRestart
[17:29:48.490]             length <- base::length
[17:29:48.490]             list <- base::list
[17:29:48.490]             seq.int <- base::seq.int
[17:29:48.490]             signalCondition <- base::signalCondition
[17:29:48.490]             sys.calls <- base::sys.calls
[17:29:48.490]             `[[` <- base::`[[`
[17:29:48.490]             `+` <- base::`+`
[17:29:48.490]             `<<-` <- base::`<<-`
[17:29:48.490]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:48.490]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:48.490]                   3L)]
[17:29:48.490]             }
[17:29:48.490]             function(cond) {
[17:29:48.490]                 is_error <- inherits(cond, "error")
[17:29:48.490]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:48.490]                   NULL)
[17:29:48.490]                 if (is_error) {
[17:29:48.490]                   sessionInformation <- function() {
[17:29:48.490]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:48.490]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:48.490]                       search = base::search(), system = base::Sys.info())
[17:29:48.490]                   }
[17:29:48.490]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.490]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:48.490]                     cond$call), session = sessionInformation(), 
[17:29:48.490]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:48.490]                   signalCondition(cond)
[17:29:48.490]                 }
[17:29:48.490]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:48.490]                 "immediateCondition"))) {
[17:29:48.490]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:48.490]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.490]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:48.490]                   if (TRUE && !signal) {
[17:29:48.490]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.490]                     {
[17:29:48.490]                       inherits <- base::inherits
[17:29:48.490]                       invokeRestart <- base::invokeRestart
[17:29:48.490]                       is.null <- base::is.null
[17:29:48.490]                       muffled <- FALSE
[17:29:48.490]                       if (inherits(cond, "message")) {
[17:29:48.490]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.490]                         if (muffled) 
[17:29:48.490]                           invokeRestart("muffleMessage")
[17:29:48.490]                       }
[17:29:48.490]                       else if (inherits(cond, "warning")) {
[17:29:48.490]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.490]                         if (muffled) 
[17:29:48.490]                           invokeRestart("muffleWarning")
[17:29:48.490]                       }
[17:29:48.490]                       else if (inherits(cond, "condition")) {
[17:29:48.490]                         if (!is.null(pattern)) {
[17:29:48.490]                           computeRestarts <- base::computeRestarts
[17:29:48.490]                           grepl <- base::grepl
[17:29:48.490]                           restarts <- computeRestarts(cond)
[17:29:48.490]                           for (restart in restarts) {
[17:29:48.490]                             name <- restart$name
[17:29:48.490]                             if (is.null(name)) 
[17:29:48.490]                               next
[17:29:48.490]                             if (!grepl(pattern, name)) 
[17:29:48.490]                               next
[17:29:48.490]                             invokeRestart(restart)
[17:29:48.490]                             muffled <- TRUE
[17:29:48.490]                             break
[17:29:48.490]                           }
[17:29:48.490]                         }
[17:29:48.490]                       }
[17:29:48.490]                       invisible(muffled)
[17:29:48.490]                     }
[17:29:48.490]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.490]                   }
[17:29:48.490]                 }
[17:29:48.490]                 else {
[17:29:48.490]                   if (TRUE) {
[17:29:48.490]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.490]                     {
[17:29:48.490]                       inherits <- base::inherits
[17:29:48.490]                       invokeRestart <- base::invokeRestart
[17:29:48.490]                       is.null <- base::is.null
[17:29:48.490]                       muffled <- FALSE
[17:29:48.490]                       if (inherits(cond, "message")) {
[17:29:48.490]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.490]                         if (muffled) 
[17:29:48.490]                           invokeRestart("muffleMessage")
[17:29:48.490]                       }
[17:29:48.490]                       else if (inherits(cond, "warning")) {
[17:29:48.490]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.490]                         if (muffled) 
[17:29:48.490]                           invokeRestart("muffleWarning")
[17:29:48.490]                       }
[17:29:48.490]                       else if (inherits(cond, "condition")) {
[17:29:48.490]                         if (!is.null(pattern)) {
[17:29:48.490]                           computeRestarts <- base::computeRestarts
[17:29:48.490]                           grepl <- base::grepl
[17:29:48.490]                           restarts <- computeRestarts(cond)
[17:29:48.490]                           for (restart in restarts) {
[17:29:48.490]                             name <- restart$name
[17:29:48.490]                             if (is.null(name)) 
[17:29:48.490]                               next
[17:29:48.490]                             if (!grepl(pattern, name)) 
[17:29:48.490]                               next
[17:29:48.490]                             invokeRestart(restart)
[17:29:48.490]                             muffled <- TRUE
[17:29:48.490]                             break
[17:29:48.490]                           }
[17:29:48.490]                         }
[17:29:48.490]                       }
[17:29:48.490]                       invisible(muffled)
[17:29:48.490]                     }
[17:29:48.490]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.490]                   }
[17:29:48.490]                 }
[17:29:48.490]             }
[17:29:48.490]         }))
[17:29:48.490]     }, error = function(ex) {
[17:29:48.490]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:48.490]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.490]                 ...future.rng), started = ...future.startTime, 
[17:29:48.490]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:48.490]             version = "1.8"), class = "FutureResult")
[17:29:48.490]     }, finally = {
[17:29:48.490]         if (!identical(...future.workdir, getwd())) 
[17:29:48.490]             setwd(...future.workdir)
[17:29:48.490]         {
[17:29:48.490]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:48.490]                 ...future.oldOptions$nwarnings <- NULL
[17:29:48.490]             }
[17:29:48.490]             base::options(...future.oldOptions)
[17:29:48.490]             if (.Platform$OS.type == "windows") {
[17:29:48.490]                 old_names <- names(...future.oldEnvVars)
[17:29:48.490]                 envs <- base::Sys.getenv()
[17:29:48.490]                 names <- names(envs)
[17:29:48.490]                 common <- intersect(names, old_names)
[17:29:48.490]                 added <- setdiff(names, old_names)
[17:29:48.490]                 removed <- setdiff(old_names, names)
[17:29:48.490]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:48.490]                   envs[common]]
[17:29:48.490]                 NAMES <- toupper(changed)
[17:29:48.490]                 args <- list()
[17:29:48.490]                 for (kk in seq_along(NAMES)) {
[17:29:48.490]                   name <- changed[[kk]]
[17:29:48.490]                   NAME <- NAMES[[kk]]
[17:29:48.490]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.490]                     next
[17:29:48.490]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.490]                 }
[17:29:48.490]                 NAMES <- toupper(added)
[17:29:48.490]                 for (kk in seq_along(NAMES)) {
[17:29:48.490]                   name <- added[[kk]]
[17:29:48.490]                   NAME <- NAMES[[kk]]
[17:29:48.490]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.490]                     next
[17:29:48.490]                   args[[name]] <- ""
[17:29:48.490]                 }
[17:29:48.490]                 NAMES <- toupper(removed)
[17:29:48.490]                 for (kk in seq_along(NAMES)) {
[17:29:48.490]                   name <- removed[[kk]]
[17:29:48.490]                   NAME <- NAMES[[kk]]
[17:29:48.490]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.490]                     next
[17:29:48.490]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.490]                 }
[17:29:48.490]                 if (length(args) > 0) 
[17:29:48.490]                   base::do.call(base::Sys.setenv, args = args)
[17:29:48.490]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:48.490]             }
[17:29:48.490]             else {
[17:29:48.490]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:48.490]             }
[17:29:48.490]             {
[17:29:48.490]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:48.490]                   0L) {
[17:29:48.490]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:48.490]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:48.490]                   base::options(opts)
[17:29:48.490]                 }
[17:29:48.490]                 {
[17:29:48.490]                   {
[17:29:48.490]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:48.490]                     NULL
[17:29:48.490]                   }
[17:29:48.490]                   options(future.plan = NULL)
[17:29:48.490]                   if (is.na(NA_character_)) 
[17:29:48.490]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.490]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:48.490]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:48.490]                     .init = FALSE)
[17:29:48.490]                 }
[17:29:48.490]             }
[17:29:48.490]         }
[17:29:48.490]     })
[17:29:48.490]     if (TRUE) {
[17:29:48.490]         base::sink(type = "output", split = FALSE)
[17:29:48.490]         if (TRUE) {
[17:29:48.490]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:48.490]         }
[17:29:48.490]         else {
[17:29:48.490]             ...future.result["stdout"] <- base::list(NULL)
[17:29:48.490]         }
[17:29:48.490]         base::close(...future.stdout)
[17:29:48.490]         ...future.stdout <- NULL
[17:29:48.490]     }
[17:29:48.490]     ...future.result$conditions <- ...future.conditions
[17:29:48.490]     ...future.result$finished <- base::Sys.time()
[17:29:48.490]     ...future.result
[17:29:48.490] }
[17:29:48.499] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:48.499] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:48.500] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:48.500] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:48.501] MultisessionFuture started
[17:29:48.501] - Launch lazy future ... done
[17:29:48.501] run() for 'MultisessionFuture' ... done
[17:29:48.502] getGlobalsAndPackages() ...
[17:29:48.502] Searching for globals...
[17:29:48.504] - globals found: [3] '{', 'sample', 'x'
[17:29:48.504] Searching for globals ... DONE
[17:29:48.504] Resolving globals: FALSE
[17:29:48.505] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:48.506] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:48.506] - globals: [1] 'x'
[17:29:48.506] 
[17:29:48.506] getGlobalsAndPackages() ... DONE
[17:29:48.507] run() for 'Future' ...
[17:29:48.507] - state: 'created'
[17:29:48.507] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:48.523] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:48.523] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:48.523]   - Field: 'node'
[17:29:48.524]   - Field: 'label'
[17:29:48.524]   - Field: 'local'
[17:29:48.524]   - Field: 'owner'
[17:29:48.524]   - Field: 'envir'
[17:29:48.524]   - Field: 'workers'
[17:29:48.524]   - Field: 'packages'
[17:29:48.525]   - Field: 'gc'
[17:29:48.525]   - Field: 'conditions'
[17:29:48.525]   - Field: 'persistent'
[17:29:48.525]   - Field: 'expr'
[17:29:48.525]   - Field: 'uuid'
[17:29:48.526]   - Field: 'seed'
[17:29:48.526]   - Field: 'version'
[17:29:48.526]   - Field: 'result'
[17:29:48.526]   - Field: 'asynchronous'
[17:29:48.526]   - Field: 'calls'
[17:29:48.527]   - Field: 'globals'
[17:29:48.527]   - Field: 'stdout'
[17:29:48.527]   - Field: 'earlySignal'
[17:29:48.527]   - Field: 'lazy'
[17:29:48.527]   - Field: 'state'
[17:29:48.527] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:48.528] - Launch lazy future ...
[17:29:48.528] Packages needed by the future expression (n = 0): <none>
[17:29:48.528] Packages needed by future strategies (n = 0): <none>
[17:29:48.529] {
[17:29:48.529]     {
[17:29:48.529]         {
[17:29:48.529]             ...future.startTime <- base::Sys.time()
[17:29:48.529]             {
[17:29:48.529]                 {
[17:29:48.529]                   {
[17:29:48.529]                     {
[17:29:48.529]                       base::local({
[17:29:48.529]                         has_future <- base::requireNamespace("future", 
[17:29:48.529]                           quietly = TRUE)
[17:29:48.529]                         if (has_future) {
[17:29:48.529]                           ns <- base::getNamespace("future")
[17:29:48.529]                           version <- ns[[".package"]][["version"]]
[17:29:48.529]                           if (is.null(version)) 
[17:29:48.529]                             version <- utils::packageVersion("future")
[17:29:48.529]                         }
[17:29:48.529]                         else {
[17:29:48.529]                           version <- NULL
[17:29:48.529]                         }
[17:29:48.529]                         if (!has_future || version < "1.8.0") {
[17:29:48.529]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:48.529]                             "", base::R.version$version.string), 
[17:29:48.529]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:48.529]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:48.529]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:48.529]                               "release", "version")], collapse = " "), 
[17:29:48.529]                             hostname = base::Sys.info()[["nodename"]])
[17:29:48.529]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:48.529]                             info)
[17:29:48.529]                           info <- base::paste(info, collapse = "; ")
[17:29:48.529]                           if (!has_future) {
[17:29:48.529]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:48.529]                               info)
[17:29:48.529]                           }
[17:29:48.529]                           else {
[17:29:48.529]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:48.529]                               info, version)
[17:29:48.529]                           }
[17:29:48.529]                           base::stop(msg)
[17:29:48.529]                         }
[17:29:48.529]                       })
[17:29:48.529]                     }
[17:29:48.529]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:48.529]                     base::options(mc.cores = 1L)
[17:29:48.529]                   }
[17:29:48.529]                   ...future.strategy.old <- future::plan("list")
[17:29:48.529]                   options(future.plan = NULL)
[17:29:48.529]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.529]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:48.529]                 }
[17:29:48.529]                 ...future.workdir <- getwd()
[17:29:48.529]             }
[17:29:48.529]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:48.529]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:48.529]         }
[17:29:48.529]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:48.529]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:48.529]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:48.529]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:48.529]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:48.529]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:48.529]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:48.529]             base::names(...future.oldOptions))
[17:29:48.529]     }
[17:29:48.529]     if (FALSE) {
[17:29:48.529]     }
[17:29:48.529]     else {
[17:29:48.529]         if (TRUE) {
[17:29:48.529]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:48.529]                 open = "w")
[17:29:48.529]         }
[17:29:48.529]         else {
[17:29:48.529]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:48.529]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:48.529]         }
[17:29:48.529]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:48.529]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:48.529]             base::sink(type = "output", split = FALSE)
[17:29:48.529]             base::close(...future.stdout)
[17:29:48.529]         }, add = TRUE)
[17:29:48.529]     }
[17:29:48.529]     ...future.frame <- base::sys.nframe()
[17:29:48.529]     ...future.conditions <- base::list()
[17:29:48.529]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:48.529]     if (FALSE) {
[17:29:48.529]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:48.529]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:48.529]     }
[17:29:48.529]     ...future.result <- base::tryCatch({
[17:29:48.529]         base::withCallingHandlers({
[17:29:48.529]             ...future.value <- base::withVisible(base::local({
[17:29:48.529]                 ...future.makeSendCondition <- base::local({
[17:29:48.529]                   sendCondition <- NULL
[17:29:48.529]                   function(frame = 1L) {
[17:29:48.529]                     if (is.function(sendCondition)) 
[17:29:48.529]                       return(sendCondition)
[17:29:48.529]                     ns <- getNamespace("parallel")
[17:29:48.529]                     if (exists("sendData", mode = "function", 
[17:29:48.529]                       envir = ns)) {
[17:29:48.529]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:48.529]                         envir = ns)
[17:29:48.529]                       envir <- sys.frame(frame)
[17:29:48.529]                       master <- NULL
[17:29:48.529]                       while (!identical(envir, .GlobalEnv) && 
[17:29:48.529]                         !identical(envir, emptyenv())) {
[17:29:48.529]                         if (exists("master", mode = "list", envir = envir, 
[17:29:48.529]                           inherits = FALSE)) {
[17:29:48.529]                           master <- get("master", mode = "list", 
[17:29:48.529]                             envir = envir, inherits = FALSE)
[17:29:48.529]                           if (inherits(master, c("SOCKnode", 
[17:29:48.529]                             "SOCK0node"))) {
[17:29:48.529]                             sendCondition <<- function(cond) {
[17:29:48.529]                               data <- list(type = "VALUE", value = cond, 
[17:29:48.529]                                 success = TRUE)
[17:29:48.529]                               parallel_sendData(master, data)
[17:29:48.529]                             }
[17:29:48.529]                             return(sendCondition)
[17:29:48.529]                           }
[17:29:48.529]                         }
[17:29:48.529]                         frame <- frame + 1L
[17:29:48.529]                         envir <- sys.frame(frame)
[17:29:48.529]                       }
[17:29:48.529]                     }
[17:29:48.529]                     sendCondition <<- function(cond) NULL
[17:29:48.529]                   }
[17:29:48.529]                 })
[17:29:48.529]                 withCallingHandlers({
[17:29:48.529]                   {
[17:29:48.529]                     sample(x, size = 1L)
[17:29:48.529]                   }
[17:29:48.529]                 }, immediateCondition = function(cond) {
[17:29:48.529]                   sendCondition <- ...future.makeSendCondition()
[17:29:48.529]                   sendCondition(cond)
[17:29:48.529]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.529]                   {
[17:29:48.529]                     inherits <- base::inherits
[17:29:48.529]                     invokeRestart <- base::invokeRestart
[17:29:48.529]                     is.null <- base::is.null
[17:29:48.529]                     muffled <- FALSE
[17:29:48.529]                     if (inherits(cond, "message")) {
[17:29:48.529]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:48.529]                       if (muffled) 
[17:29:48.529]                         invokeRestart("muffleMessage")
[17:29:48.529]                     }
[17:29:48.529]                     else if (inherits(cond, "warning")) {
[17:29:48.529]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:48.529]                       if (muffled) 
[17:29:48.529]                         invokeRestart("muffleWarning")
[17:29:48.529]                     }
[17:29:48.529]                     else if (inherits(cond, "condition")) {
[17:29:48.529]                       if (!is.null(pattern)) {
[17:29:48.529]                         computeRestarts <- base::computeRestarts
[17:29:48.529]                         grepl <- base::grepl
[17:29:48.529]                         restarts <- computeRestarts(cond)
[17:29:48.529]                         for (restart in restarts) {
[17:29:48.529]                           name <- restart$name
[17:29:48.529]                           if (is.null(name)) 
[17:29:48.529]                             next
[17:29:48.529]                           if (!grepl(pattern, name)) 
[17:29:48.529]                             next
[17:29:48.529]                           invokeRestart(restart)
[17:29:48.529]                           muffled <- TRUE
[17:29:48.529]                           break
[17:29:48.529]                         }
[17:29:48.529]                       }
[17:29:48.529]                     }
[17:29:48.529]                     invisible(muffled)
[17:29:48.529]                   }
[17:29:48.529]                   muffleCondition(cond)
[17:29:48.529]                 })
[17:29:48.529]             }))
[17:29:48.529]             future::FutureResult(value = ...future.value$value, 
[17:29:48.529]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.529]                   ...future.rng), globalenv = if (FALSE) 
[17:29:48.529]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:48.529]                     ...future.globalenv.names))
[17:29:48.529]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:48.529]         }, condition = base::local({
[17:29:48.529]             c <- base::c
[17:29:48.529]             inherits <- base::inherits
[17:29:48.529]             invokeRestart <- base::invokeRestart
[17:29:48.529]             length <- base::length
[17:29:48.529]             list <- base::list
[17:29:48.529]             seq.int <- base::seq.int
[17:29:48.529]             signalCondition <- base::signalCondition
[17:29:48.529]             sys.calls <- base::sys.calls
[17:29:48.529]             `[[` <- base::`[[`
[17:29:48.529]             `+` <- base::`+`
[17:29:48.529]             `<<-` <- base::`<<-`
[17:29:48.529]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:48.529]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:48.529]                   3L)]
[17:29:48.529]             }
[17:29:48.529]             function(cond) {
[17:29:48.529]                 is_error <- inherits(cond, "error")
[17:29:48.529]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:48.529]                   NULL)
[17:29:48.529]                 if (is_error) {
[17:29:48.529]                   sessionInformation <- function() {
[17:29:48.529]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:48.529]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:48.529]                       search = base::search(), system = base::Sys.info())
[17:29:48.529]                   }
[17:29:48.529]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.529]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:48.529]                     cond$call), session = sessionInformation(), 
[17:29:48.529]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:48.529]                   signalCondition(cond)
[17:29:48.529]                 }
[17:29:48.529]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:48.529]                 "immediateCondition"))) {
[17:29:48.529]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:48.529]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.529]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:48.529]                   if (TRUE && !signal) {
[17:29:48.529]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.529]                     {
[17:29:48.529]                       inherits <- base::inherits
[17:29:48.529]                       invokeRestart <- base::invokeRestart
[17:29:48.529]                       is.null <- base::is.null
[17:29:48.529]                       muffled <- FALSE
[17:29:48.529]                       if (inherits(cond, "message")) {
[17:29:48.529]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.529]                         if (muffled) 
[17:29:48.529]                           invokeRestart("muffleMessage")
[17:29:48.529]                       }
[17:29:48.529]                       else if (inherits(cond, "warning")) {
[17:29:48.529]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.529]                         if (muffled) 
[17:29:48.529]                           invokeRestart("muffleWarning")
[17:29:48.529]                       }
[17:29:48.529]                       else if (inherits(cond, "condition")) {
[17:29:48.529]                         if (!is.null(pattern)) {
[17:29:48.529]                           computeRestarts <- base::computeRestarts
[17:29:48.529]                           grepl <- base::grepl
[17:29:48.529]                           restarts <- computeRestarts(cond)
[17:29:48.529]                           for (restart in restarts) {
[17:29:48.529]                             name <- restart$name
[17:29:48.529]                             if (is.null(name)) 
[17:29:48.529]                               next
[17:29:48.529]                             if (!grepl(pattern, name)) 
[17:29:48.529]                               next
[17:29:48.529]                             invokeRestart(restart)
[17:29:48.529]                             muffled <- TRUE
[17:29:48.529]                             break
[17:29:48.529]                           }
[17:29:48.529]                         }
[17:29:48.529]                       }
[17:29:48.529]                       invisible(muffled)
[17:29:48.529]                     }
[17:29:48.529]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.529]                   }
[17:29:48.529]                 }
[17:29:48.529]                 else {
[17:29:48.529]                   if (TRUE) {
[17:29:48.529]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.529]                     {
[17:29:48.529]                       inherits <- base::inherits
[17:29:48.529]                       invokeRestart <- base::invokeRestart
[17:29:48.529]                       is.null <- base::is.null
[17:29:48.529]                       muffled <- FALSE
[17:29:48.529]                       if (inherits(cond, "message")) {
[17:29:48.529]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.529]                         if (muffled) 
[17:29:48.529]                           invokeRestart("muffleMessage")
[17:29:48.529]                       }
[17:29:48.529]                       else if (inherits(cond, "warning")) {
[17:29:48.529]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.529]                         if (muffled) 
[17:29:48.529]                           invokeRestart("muffleWarning")
[17:29:48.529]                       }
[17:29:48.529]                       else if (inherits(cond, "condition")) {
[17:29:48.529]                         if (!is.null(pattern)) {
[17:29:48.529]                           computeRestarts <- base::computeRestarts
[17:29:48.529]                           grepl <- base::grepl
[17:29:48.529]                           restarts <- computeRestarts(cond)
[17:29:48.529]                           for (restart in restarts) {
[17:29:48.529]                             name <- restart$name
[17:29:48.529]                             if (is.null(name)) 
[17:29:48.529]                               next
[17:29:48.529]                             if (!grepl(pattern, name)) 
[17:29:48.529]                               next
[17:29:48.529]                             invokeRestart(restart)
[17:29:48.529]                             muffled <- TRUE
[17:29:48.529]                             break
[17:29:48.529]                           }
[17:29:48.529]                         }
[17:29:48.529]                       }
[17:29:48.529]                       invisible(muffled)
[17:29:48.529]                     }
[17:29:48.529]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.529]                   }
[17:29:48.529]                 }
[17:29:48.529]             }
[17:29:48.529]         }))
[17:29:48.529]     }, error = function(ex) {
[17:29:48.529]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:48.529]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.529]                 ...future.rng), started = ...future.startTime, 
[17:29:48.529]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:48.529]             version = "1.8"), class = "FutureResult")
[17:29:48.529]     }, finally = {
[17:29:48.529]         if (!identical(...future.workdir, getwd())) 
[17:29:48.529]             setwd(...future.workdir)
[17:29:48.529]         {
[17:29:48.529]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:48.529]                 ...future.oldOptions$nwarnings <- NULL
[17:29:48.529]             }
[17:29:48.529]             base::options(...future.oldOptions)
[17:29:48.529]             if (.Platform$OS.type == "windows") {
[17:29:48.529]                 old_names <- names(...future.oldEnvVars)
[17:29:48.529]                 envs <- base::Sys.getenv()
[17:29:48.529]                 names <- names(envs)
[17:29:48.529]                 common <- intersect(names, old_names)
[17:29:48.529]                 added <- setdiff(names, old_names)
[17:29:48.529]                 removed <- setdiff(old_names, names)
[17:29:48.529]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:48.529]                   envs[common]]
[17:29:48.529]                 NAMES <- toupper(changed)
[17:29:48.529]                 args <- list()
[17:29:48.529]                 for (kk in seq_along(NAMES)) {
[17:29:48.529]                   name <- changed[[kk]]
[17:29:48.529]                   NAME <- NAMES[[kk]]
[17:29:48.529]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.529]                     next
[17:29:48.529]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.529]                 }
[17:29:48.529]                 NAMES <- toupper(added)
[17:29:48.529]                 for (kk in seq_along(NAMES)) {
[17:29:48.529]                   name <- added[[kk]]
[17:29:48.529]                   NAME <- NAMES[[kk]]
[17:29:48.529]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.529]                     next
[17:29:48.529]                   args[[name]] <- ""
[17:29:48.529]                 }
[17:29:48.529]                 NAMES <- toupper(removed)
[17:29:48.529]                 for (kk in seq_along(NAMES)) {
[17:29:48.529]                   name <- removed[[kk]]
[17:29:48.529]                   NAME <- NAMES[[kk]]
[17:29:48.529]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.529]                     next
[17:29:48.529]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.529]                 }
[17:29:48.529]                 if (length(args) > 0) 
[17:29:48.529]                   base::do.call(base::Sys.setenv, args = args)
[17:29:48.529]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:48.529]             }
[17:29:48.529]             else {
[17:29:48.529]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:48.529]             }
[17:29:48.529]             {
[17:29:48.529]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:48.529]                   0L) {
[17:29:48.529]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:48.529]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:48.529]                   base::options(opts)
[17:29:48.529]                 }
[17:29:48.529]                 {
[17:29:48.529]                   {
[17:29:48.529]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:48.529]                     NULL
[17:29:48.529]                   }
[17:29:48.529]                   options(future.plan = NULL)
[17:29:48.529]                   if (is.na(NA_character_)) 
[17:29:48.529]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.529]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:48.529]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:48.529]                     .init = FALSE)
[17:29:48.529]                 }
[17:29:48.529]             }
[17:29:48.529]         }
[17:29:48.529]     })
[17:29:48.529]     if (TRUE) {
[17:29:48.529]         base::sink(type = "output", split = FALSE)
[17:29:48.529]         if (TRUE) {
[17:29:48.529]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:48.529]         }
[17:29:48.529]         else {
[17:29:48.529]             ...future.result["stdout"] <- base::list(NULL)
[17:29:48.529]         }
[17:29:48.529]         base::close(...future.stdout)
[17:29:48.529]         ...future.stdout <- NULL
[17:29:48.529]     }
[17:29:48.529]     ...future.result$conditions <- ...future.conditions
[17:29:48.529]     ...future.result$finished <- base::Sys.time()
[17:29:48.529]     ...future.result
[17:29:48.529] }
[17:29:48.534] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:48.551] receiveMessageFromWorker() for ClusterFuture ...
[17:29:48.551] - Validating connection of MultisessionFuture
[17:29:48.551] - received message: FutureResult
[17:29:48.552] - Received FutureResult
[17:29:48.552] - Erased future from FutureRegistry
[17:29:48.552] result() for ClusterFuture ...
[17:29:48.552] - result already collected: FutureResult
[17:29:48.552] result() for ClusterFuture ... done
[17:29:48.553] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:48.553] result() for ClusterFuture ...
[17:29:48.553] - result already collected: FutureResult
[17:29:48.553] result() for ClusterFuture ... done
[17:29:48.553] result() for ClusterFuture ...
[17:29:48.554] - result already collected: FutureResult
[17:29:48.554] result() for ClusterFuture ... done
[17:29:48.555] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:48.555] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:48.556] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:48.556] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:48.557] MultisessionFuture started
[17:29:48.557] - Launch lazy future ... done
[17:29:48.557] run() for 'MultisessionFuture' ... done
[17:29:48.559] getGlobalsAndPackages() ...
[17:29:48.559] Searching for globals...
[17:29:48.561] - globals found: [3] '{', 'sample', 'x'
[17:29:48.561] Searching for globals ... DONE
[17:29:48.562] Resolving globals: FALSE
[17:29:48.562] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:48.563] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:48.563] - globals: [1] 'x'
[17:29:48.564] 
[17:29:48.564] getGlobalsAndPackages() ... DONE
[17:29:48.565] run() for 'Future' ...
[17:29:48.565] - state: 'created'
[17:29:48.565] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:48.586] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:48.586] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:48.587]   - Field: 'node'
[17:29:48.587]   - Field: 'label'
[17:29:48.587]   - Field: 'local'
[17:29:48.588]   - Field: 'owner'
[17:29:48.588]   - Field: 'envir'
[17:29:48.588]   - Field: 'workers'
[17:29:48.589]   - Field: 'packages'
[17:29:48.589]   - Field: 'gc'
[17:29:48.589]   - Field: 'conditions'
[17:29:48.589]   - Field: 'persistent'
[17:29:48.590]   - Field: 'expr'
[17:29:48.590]   - Field: 'uuid'
[17:29:48.590]   - Field: 'seed'
[17:29:48.591]   - Field: 'version'
[17:29:48.591]   - Field: 'result'
[17:29:48.591]   - Field: 'asynchronous'
[17:29:48.592]   - Field: 'calls'
[17:29:48.592]   - Field: 'globals'
[17:29:48.592]   - Field: 'stdout'
[17:29:48.592]   - Field: 'earlySignal'
[17:29:48.593]   - Field: 'lazy'
[17:29:48.593]   - Field: 'state'
[17:29:48.593] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:48.594] - Launch lazy future ...
[17:29:48.594] Packages needed by the future expression (n = 0): <none>
[17:29:48.595] Packages needed by future strategies (n = 0): <none>
[17:29:48.596] {
[17:29:48.596]     {
[17:29:48.596]         {
[17:29:48.596]             ...future.startTime <- base::Sys.time()
[17:29:48.596]             {
[17:29:48.596]                 {
[17:29:48.596]                   {
[17:29:48.596]                     {
[17:29:48.596]                       base::local({
[17:29:48.596]                         has_future <- base::requireNamespace("future", 
[17:29:48.596]                           quietly = TRUE)
[17:29:48.596]                         if (has_future) {
[17:29:48.596]                           ns <- base::getNamespace("future")
[17:29:48.596]                           version <- ns[[".package"]][["version"]]
[17:29:48.596]                           if (is.null(version)) 
[17:29:48.596]                             version <- utils::packageVersion("future")
[17:29:48.596]                         }
[17:29:48.596]                         else {
[17:29:48.596]                           version <- NULL
[17:29:48.596]                         }
[17:29:48.596]                         if (!has_future || version < "1.8.0") {
[17:29:48.596]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:48.596]                             "", base::R.version$version.string), 
[17:29:48.596]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:48.596]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:48.596]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:48.596]                               "release", "version")], collapse = " "), 
[17:29:48.596]                             hostname = base::Sys.info()[["nodename"]])
[17:29:48.596]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:48.596]                             info)
[17:29:48.596]                           info <- base::paste(info, collapse = "; ")
[17:29:48.596]                           if (!has_future) {
[17:29:48.596]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:48.596]                               info)
[17:29:48.596]                           }
[17:29:48.596]                           else {
[17:29:48.596]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:48.596]                               info, version)
[17:29:48.596]                           }
[17:29:48.596]                           base::stop(msg)
[17:29:48.596]                         }
[17:29:48.596]                       })
[17:29:48.596]                     }
[17:29:48.596]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:48.596]                     base::options(mc.cores = 1L)
[17:29:48.596]                   }
[17:29:48.596]                   ...future.strategy.old <- future::plan("list")
[17:29:48.596]                   options(future.plan = NULL)
[17:29:48.596]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.596]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:48.596]                 }
[17:29:48.596]                 ...future.workdir <- getwd()
[17:29:48.596]             }
[17:29:48.596]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:48.596]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:48.596]         }
[17:29:48.596]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:48.596]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:48.596]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:48.596]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:48.596]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:48.596]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:48.596]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:48.596]             base::names(...future.oldOptions))
[17:29:48.596]     }
[17:29:48.596]     if (FALSE) {
[17:29:48.596]     }
[17:29:48.596]     else {
[17:29:48.596]         if (TRUE) {
[17:29:48.596]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:48.596]                 open = "w")
[17:29:48.596]         }
[17:29:48.596]         else {
[17:29:48.596]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:48.596]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:48.596]         }
[17:29:48.596]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:48.596]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:48.596]             base::sink(type = "output", split = FALSE)
[17:29:48.596]             base::close(...future.stdout)
[17:29:48.596]         }, add = TRUE)
[17:29:48.596]     }
[17:29:48.596]     ...future.frame <- base::sys.nframe()
[17:29:48.596]     ...future.conditions <- base::list()
[17:29:48.596]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:48.596]     if (FALSE) {
[17:29:48.596]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:48.596]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:48.596]     }
[17:29:48.596]     ...future.result <- base::tryCatch({
[17:29:48.596]         base::withCallingHandlers({
[17:29:48.596]             ...future.value <- base::withVisible(base::local({
[17:29:48.596]                 ...future.makeSendCondition <- base::local({
[17:29:48.596]                   sendCondition <- NULL
[17:29:48.596]                   function(frame = 1L) {
[17:29:48.596]                     if (is.function(sendCondition)) 
[17:29:48.596]                       return(sendCondition)
[17:29:48.596]                     ns <- getNamespace("parallel")
[17:29:48.596]                     if (exists("sendData", mode = "function", 
[17:29:48.596]                       envir = ns)) {
[17:29:48.596]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:48.596]                         envir = ns)
[17:29:48.596]                       envir <- sys.frame(frame)
[17:29:48.596]                       master <- NULL
[17:29:48.596]                       while (!identical(envir, .GlobalEnv) && 
[17:29:48.596]                         !identical(envir, emptyenv())) {
[17:29:48.596]                         if (exists("master", mode = "list", envir = envir, 
[17:29:48.596]                           inherits = FALSE)) {
[17:29:48.596]                           master <- get("master", mode = "list", 
[17:29:48.596]                             envir = envir, inherits = FALSE)
[17:29:48.596]                           if (inherits(master, c("SOCKnode", 
[17:29:48.596]                             "SOCK0node"))) {
[17:29:48.596]                             sendCondition <<- function(cond) {
[17:29:48.596]                               data <- list(type = "VALUE", value = cond, 
[17:29:48.596]                                 success = TRUE)
[17:29:48.596]                               parallel_sendData(master, data)
[17:29:48.596]                             }
[17:29:48.596]                             return(sendCondition)
[17:29:48.596]                           }
[17:29:48.596]                         }
[17:29:48.596]                         frame <- frame + 1L
[17:29:48.596]                         envir <- sys.frame(frame)
[17:29:48.596]                       }
[17:29:48.596]                     }
[17:29:48.596]                     sendCondition <<- function(cond) NULL
[17:29:48.596]                   }
[17:29:48.596]                 })
[17:29:48.596]                 withCallingHandlers({
[17:29:48.596]                   {
[17:29:48.596]                     sample(x, size = 1L)
[17:29:48.596]                   }
[17:29:48.596]                 }, immediateCondition = function(cond) {
[17:29:48.596]                   sendCondition <- ...future.makeSendCondition()
[17:29:48.596]                   sendCondition(cond)
[17:29:48.596]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.596]                   {
[17:29:48.596]                     inherits <- base::inherits
[17:29:48.596]                     invokeRestart <- base::invokeRestart
[17:29:48.596]                     is.null <- base::is.null
[17:29:48.596]                     muffled <- FALSE
[17:29:48.596]                     if (inherits(cond, "message")) {
[17:29:48.596]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:48.596]                       if (muffled) 
[17:29:48.596]                         invokeRestart("muffleMessage")
[17:29:48.596]                     }
[17:29:48.596]                     else if (inherits(cond, "warning")) {
[17:29:48.596]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:48.596]                       if (muffled) 
[17:29:48.596]                         invokeRestart("muffleWarning")
[17:29:48.596]                     }
[17:29:48.596]                     else if (inherits(cond, "condition")) {
[17:29:48.596]                       if (!is.null(pattern)) {
[17:29:48.596]                         computeRestarts <- base::computeRestarts
[17:29:48.596]                         grepl <- base::grepl
[17:29:48.596]                         restarts <- computeRestarts(cond)
[17:29:48.596]                         for (restart in restarts) {
[17:29:48.596]                           name <- restart$name
[17:29:48.596]                           if (is.null(name)) 
[17:29:48.596]                             next
[17:29:48.596]                           if (!grepl(pattern, name)) 
[17:29:48.596]                             next
[17:29:48.596]                           invokeRestart(restart)
[17:29:48.596]                           muffled <- TRUE
[17:29:48.596]                           break
[17:29:48.596]                         }
[17:29:48.596]                       }
[17:29:48.596]                     }
[17:29:48.596]                     invisible(muffled)
[17:29:48.596]                   }
[17:29:48.596]                   muffleCondition(cond)
[17:29:48.596]                 })
[17:29:48.596]             }))
[17:29:48.596]             future::FutureResult(value = ...future.value$value, 
[17:29:48.596]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.596]                   ...future.rng), globalenv = if (FALSE) 
[17:29:48.596]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:48.596]                     ...future.globalenv.names))
[17:29:48.596]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:48.596]         }, condition = base::local({
[17:29:48.596]             c <- base::c
[17:29:48.596]             inherits <- base::inherits
[17:29:48.596]             invokeRestart <- base::invokeRestart
[17:29:48.596]             length <- base::length
[17:29:48.596]             list <- base::list
[17:29:48.596]             seq.int <- base::seq.int
[17:29:48.596]             signalCondition <- base::signalCondition
[17:29:48.596]             sys.calls <- base::sys.calls
[17:29:48.596]             `[[` <- base::`[[`
[17:29:48.596]             `+` <- base::`+`
[17:29:48.596]             `<<-` <- base::`<<-`
[17:29:48.596]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:48.596]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:48.596]                   3L)]
[17:29:48.596]             }
[17:29:48.596]             function(cond) {
[17:29:48.596]                 is_error <- inherits(cond, "error")
[17:29:48.596]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:48.596]                   NULL)
[17:29:48.596]                 if (is_error) {
[17:29:48.596]                   sessionInformation <- function() {
[17:29:48.596]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:48.596]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:48.596]                       search = base::search(), system = base::Sys.info())
[17:29:48.596]                   }
[17:29:48.596]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.596]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:48.596]                     cond$call), session = sessionInformation(), 
[17:29:48.596]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:48.596]                   signalCondition(cond)
[17:29:48.596]                 }
[17:29:48.596]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:48.596]                 "immediateCondition"))) {
[17:29:48.596]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:48.596]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.596]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:48.596]                   if (TRUE && !signal) {
[17:29:48.596]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.596]                     {
[17:29:48.596]                       inherits <- base::inherits
[17:29:48.596]                       invokeRestart <- base::invokeRestart
[17:29:48.596]                       is.null <- base::is.null
[17:29:48.596]                       muffled <- FALSE
[17:29:48.596]                       if (inherits(cond, "message")) {
[17:29:48.596]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.596]                         if (muffled) 
[17:29:48.596]                           invokeRestart("muffleMessage")
[17:29:48.596]                       }
[17:29:48.596]                       else if (inherits(cond, "warning")) {
[17:29:48.596]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.596]                         if (muffled) 
[17:29:48.596]                           invokeRestart("muffleWarning")
[17:29:48.596]                       }
[17:29:48.596]                       else if (inherits(cond, "condition")) {
[17:29:48.596]                         if (!is.null(pattern)) {
[17:29:48.596]                           computeRestarts <- base::computeRestarts
[17:29:48.596]                           grepl <- base::grepl
[17:29:48.596]                           restarts <- computeRestarts(cond)
[17:29:48.596]                           for (restart in restarts) {
[17:29:48.596]                             name <- restart$name
[17:29:48.596]                             if (is.null(name)) 
[17:29:48.596]                               next
[17:29:48.596]                             if (!grepl(pattern, name)) 
[17:29:48.596]                               next
[17:29:48.596]                             invokeRestart(restart)
[17:29:48.596]                             muffled <- TRUE
[17:29:48.596]                             break
[17:29:48.596]                           }
[17:29:48.596]                         }
[17:29:48.596]                       }
[17:29:48.596]                       invisible(muffled)
[17:29:48.596]                     }
[17:29:48.596]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.596]                   }
[17:29:48.596]                 }
[17:29:48.596]                 else {
[17:29:48.596]                   if (TRUE) {
[17:29:48.596]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.596]                     {
[17:29:48.596]                       inherits <- base::inherits
[17:29:48.596]                       invokeRestart <- base::invokeRestart
[17:29:48.596]                       is.null <- base::is.null
[17:29:48.596]                       muffled <- FALSE
[17:29:48.596]                       if (inherits(cond, "message")) {
[17:29:48.596]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.596]                         if (muffled) 
[17:29:48.596]                           invokeRestart("muffleMessage")
[17:29:48.596]                       }
[17:29:48.596]                       else if (inherits(cond, "warning")) {
[17:29:48.596]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.596]                         if (muffled) 
[17:29:48.596]                           invokeRestart("muffleWarning")
[17:29:48.596]                       }
[17:29:48.596]                       else if (inherits(cond, "condition")) {
[17:29:48.596]                         if (!is.null(pattern)) {
[17:29:48.596]                           computeRestarts <- base::computeRestarts
[17:29:48.596]                           grepl <- base::grepl
[17:29:48.596]                           restarts <- computeRestarts(cond)
[17:29:48.596]                           for (restart in restarts) {
[17:29:48.596]                             name <- restart$name
[17:29:48.596]                             if (is.null(name)) 
[17:29:48.596]                               next
[17:29:48.596]                             if (!grepl(pattern, name)) 
[17:29:48.596]                               next
[17:29:48.596]                             invokeRestart(restart)
[17:29:48.596]                             muffled <- TRUE
[17:29:48.596]                             break
[17:29:48.596]                           }
[17:29:48.596]                         }
[17:29:48.596]                       }
[17:29:48.596]                       invisible(muffled)
[17:29:48.596]                     }
[17:29:48.596]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.596]                   }
[17:29:48.596]                 }
[17:29:48.596]             }
[17:29:48.596]         }))
[17:29:48.596]     }, error = function(ex) {
[17:29:48.596]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:48.596]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.596]                 ...future.rng), started = ...future.startTime, 
[17:29:48.596]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:48.596]             version = "1.8"), class = "FutureResult")
[17:29:48.596]     }, finally = {
[17:29:48.596]         if (!identical(...future.workdir, getwd())) 
[17:29:48.596]             setwd(...future.workdir)
[17:29:48.596]         {
[17:29:48.596]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:48.596]                 ...future.oldOptions$nwarnings <- NULL
[17:29:48.596]             }
[17:29:48.596]             base::options(...future.oldOptions)
[17:29:48.596]             if (.Platform$OS.type == "windows") {
[17:29:48.596]                 old_names <- names(...future.oldEnvVars)
[17:29:48.596]                 envs <- base::Sys.getenv()
[17:29:48.596]                 names <- names(envs)
[17:29:48.596]                 common <- intersect(names, old_names)
[17:29:48.596]                 added <- setdiff(names, old_names)
[17:29:48.596]                 removed <- setdiff(old_names, names)
[17:29:48.596]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:48.596]                   envs[common]]
[17:29:48.596]                 NAMES <- toupper(changed)
[17:29:48.596]                 args <- list()
[17:29:48.596]                 for (kk in seq_along(NAMES)) {
[17:29:48.596]                   name <- changed[[kk]]
[17:29:48.596]                   NAME <- NAMES[[kk]]
[17:29:48.596]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.596]                     next
[17:29:48.596]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.596]                 }
[17:29:48.596]                 NAMES <- toupper(added)
[17:29:48.596]                 for (kk in seq_along(NAMES)) {
[17:29:48.596]                   name <- added[[kk]]
[17:29:48.596]                   NAME <- NAMES[[kk]]
[17:29:48.596]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.596]                     next
[17:29:48.596]                   args[[name]] <- ""
[17:29:48.596]                 }
[17:29:48.596]                 NAMES <- toupper(removed)
[17:29:48.596]                 for (kk in seq_along(NAMES)) {
[17:29:48.596]                   name <- removed[[kk]]
[17:29:48.596]                   NAME <- NAMES[[kk]]
[17:29:48.596]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.596]                     next
[17:29:48.596]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.596]                 }
[17:29:48.596]                 if (length(args) > 0) 
[17:29:48.596]                   base::do.call(base::Sys.setenv, args = args)
[17:29:48.596]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:48.596]             }
[17:29:48.596]             else {
[17:29:48.596]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:48.596]             }
[17:29:48.596]             {
[17:29:48.596]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:48.596]                   0L) {
[17:29:48.596]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:48.596]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:48.596]                   base::options(opts)
[17:29:48.596]                 }
[17:29:48.596]                 {
[17:29:48.596]                   {
[17:29:48.596]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:48.596]                     NULL
[17:29:48.596]                   }
[17:29:48.596]                   options(future.plan = NULL)
[17:29:48.596]                   if (is.na(NA_character_)) 
[17:29:48.596]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.596]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:48.596]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:48.596]                     .init = FALSE)
[17:29:48.596]                 }
[17:29:48.596]             }
[17:29:48.596]         }
[17:29:48.596]     })
[17:29:48.596]     if (TRUE) {
[17:29:48.596]         base::sink(type = "output", split = FALSE)
[17:29:48.596]         if (TRUE) {
[17:29:48.596]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:48.596]         }
[17:29:48.596]         else {
[17:29:48.596]             ...future.result["stdout"] <- base::list(NULL)
[17:29:48.596]         }
[17:29:48.596]         base::close(...future.stdout)
[17:29:48.596]         ...future.stdout <- NULL
[17:29:48.596]     }
[17:29:48.596]     ...future.result$conditions <- ...future.conditions
[17:29:48.596]     ...future.result$finished <- base::Sys.time()
[17:29:48.596]     ...future.result
[17:29:48.596] }
[17:29:48.604] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:48.629] receiveMessageFromWorker() for ClusterFuture ...
[17:29:48.630] - Validating connection of MultisessionFuture
[17:29:48.630] - received message: FutureResult
[17:29:48.630] - Received FutureResult
[17:29:48.631] - Erased future from FutureRegistry
[17:29:48.631] result() for ClusterFuture ...
[17:29:48.631] - result already collected: FutureResult
[17:29:48.632] result() for ClusterFuture ... done
[17:29:48.632] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:48.632] result() for ClusterFuture ...
[17:29:48.633] - result already collected: FutureResult
[17:29:48.633] result() for ClusterFuture ... done
[17:29:48.633] result() for ClusterFuture ...
[17:29:48.633] - result already collected: FutureResult
[17:29:48.633] result() for ClusterFuture ... done
[17:29:48.635] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:48.636] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:48.636] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:48.637] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:48.638] MultisessionFuture started
[17:29:48.638] - Launch lazy future ... done
[17:29:48.638] run() for 'MultisessionFuture' ... done
[17:29:48.639] result() for ClusterFuture ...
[17:29:48.639] - result already collected: FutureResult
[17:29:48.640] result() for ClusterFuture ... done
[17:29:48.640] result() for ClusterFuture ...
[17:29:48.640] - result already collected: FutureResult
[17:29:48.640] result() for ClusterFuture ... done
[17:29:48.641] signalConditions() ...
[17:29:48.641]  - include = 'immediateCondition'
[17:29:48.641]  - exclude = 
[17:29:48.641]  - resignal = FALSE
[17:29:48.642]  - Number of conditions: 1
[17:29:48.642] signalConditions() ... done
[17:29:48.642] Future state: 'finished'
[17:29:48.643] result() for ClusterFuture ...
[17:29:48.643] - result already collected: FutureResult
[17:29:48.643] result() for ClusterFuture ... done
[17:29:48.644] signalConditions() ...
[17:29:48.644]  - include = 'condition'
[17:29:48.644]  - exclude = 'immediateCondition'
[17:29:48.645]  - resignal = TRUE
[17:29:48.645]  - Number of conditions: 1
[17:29:48.645]  - Condition #1: 'RngFutureError', 'FutureError', 'error', 'RngFutureCondition', 'FutureCondition', 'condition'
[17:29:48.646] signalConditions() ... done
<RngFutureError: UNRELIABLE VALUE: Future ('fsample_1-218749') 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: 74bc5e8d-33ad-1075-1b44-12da2fefbfd3


DEBUG: BEGIN TROUBLESHOOTING HELP
Future involved:
MultisessionFuture:
Label: 'fsample_1-218749'
Expression:
{
    sample(x, size = 1L)
}
Lazy evaluation: FALSE
Asynchronous evaluation: TRUE
Local evaluation: TRUE
Environment: 0x000001add7a60060
Capture standard output: TRUE
Capture condition classes: 'condition' (excluding 'nothing')
Globals: 1 objects totaling 133 bytes (integer 'x' of 133 bytes)
Packages: <none>
L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
Resolved: TRUE
Value: 35 bytes of class 'integer'
Conditions captured: [n=1] 'RngFutureError'
Early signaling: FALSE
Owner process: 09ba3688-2e53-09b0-80cd-b3e16136bfe0
Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'

DEBUG: END TROUBLESHOOTING HELP
[17:29:48.649] getGlobalsAndPackages() ...
[17:29:48.650] Searching for globals...
[17:29:48.652] - globals found: [3] '{', 'sample', 'x'
[17:29:48.652] Searching for globals ... DONE
[17:29:48.652] Resolving globals: FALSE
[17:29:48.653] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:48.654] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:48.654] - globals: [1] 'x'
[17:29:48.655] 
[17:29:48.655] getGlobalsAndPackages() ... DONE
[17:29:48.656] run() for 'Future' ...
[17:29:48.656] - state: 'created'
[17:29:48.657] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:48.680] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:48.681] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:48.681]   - Field: 'node'
[17:29:48.681]   - Field: 'label'
[17:29:48.682]   - Field: 'local'
[17:29:48.682]   - Field: 'owner'
[17:29:48.682]   - Field: 'envir'
[17:29:48.683]   - Field: 'workers'
[17:29:48.683]   - Field: 'packages'
[17:29:48.683]   - Field: 'gc'
[17:29:48.683]   - Field: 'conditions'
[17:29:48.684]   - Field: 'persistent'
[17:29:48.684]   - Field: 'expr'
[17:29:48.684]   - Field: 'uuid'
[17:29:48.685]   - Field: 'seed'
[17:29:48.685]   - Field: 'version'
[17:29:48.685]   - Field: 'result'
[17:29:48.686]   - Field: 'asynchronous'
[17:29:48.686]   - Field: 'calls'
[17:29:48.686]   - Field: 'globals'
[17:29:48.687]   - Field: 'stdout'
[17:29:48.687]   - Field: 'earlySignal'
[17:29:48.687]   - Field: 'lazy'
[17:29:48.688]   - Field: 'state'
[17:29:48.688] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:48.688] - Launch lazy future ...
[17:29:48.689] Packages needed by the future expression (n = 0): <none>
[17:29:48.689] Packages needed by future strategies (n = 0): <none>
[17:29:48.690] {
[17:29:48.690]     {
[17:29:48.690]         {
[17:29:48.690]             ...future.startTime <- base::Sys.time()
[17:29:48.690]             {
[17:29:48.690]                 {
[17:29:48.690]                   {
[17:29:48.690]                     {
[17:29:48.690]                       base::local({
[17:29:48.690]                         has_future <- base::requireNamespace("future", 
[17:29:48.690]                           quietly = TRUE)
[17:29:48.690]                         if (has_future) {
[17:29:48.690]                           ns <- base::getNamespace("future")
[17:29:48.690]                           version <- ns[[".package"]][["version"]]
[17:29:48.690]                           if (is.null(version)) 
[17:29:48.690]                             version <- utils::packageVersion("future")
[17:29:48.690]                         }
[17:29:48.690]                         else {
[17:29:48.690]                           version <- NULL
[17:29:48.690]                         }
[17:29:48.690]                         if (!has_future || version < "1.8.0") {
[17:29:48.690]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:48.690]                             "", base::R.version$version.string), 
[17:29:48.690]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:48.690]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:48.690]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:48.690]                               "release", "version")], collapse = " "), 
[17:29:48.690]                             hostname = base::Sys.info()[["nodename"]])
[17:29:48.690]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:48.690]                             info)
[17:29:48.690]                           info <- base::paste(info, collapse = "; ")
[17:29:48.690]                           if (!has_future) {
[17:29:48.690]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:48.690]                               info)
[17:29:48.690]                           }
[17:29:48.690]                           else {
[17:29:48.690]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:48.690]                               info, version)
[17:29:48.690]                           }
[17:29:48.690]                           base::stop(msg)
[17:29:48.690]                         }
[17:29:48.690]                       })
[17:29:48.690]                     }
[17:29:48.690]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:48.690]                     base::options(mc.cores = 1L)
[17:29:48.690]                   }
[17:29:48.690]                   ...future.strategy.old <- future::plan("list")
[17:29:48.690]                   options(future.plan = NULL)
[17:29:48.690]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.690]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:48.690]                 }
[17:29:48.690]                 ...future.workdir <- getwd()
[17:29:48.690]             }
[17:29:48.690]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:48.690]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:48.690]         }
[17:29:48.690]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:48.690]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:48.690]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:48.690]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:48.690]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:48.690]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:48.690]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:48.690]             base::names(...future.oldOptions))
[17:29:48.690]     }
[17:29:48.690]     if (FALSE) {
[17:29:48.690]     }
[17:29:48.690]     else {
[17:29:48.690]         if (TRUE) {
[17:29:48.690]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:48.690]                 open = "w")
[17:29:48.690]         }
[17:29:48.690]         else {
[17:29:48.690]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:48.690]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:48.690]         }
[17:29:48.690]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:48.690]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:48.690]             base::sink(type = "output", split = FALSE)
[17:29:48.690]             base::close(...future.stdout)
[17:29:48.690]         }, add = TRUE)
[17:29:48.690]     }
[17:29:48.690]     ...future.frame <- base::sys.nframe()
[17:29:48.690]     ...future.conditions <- base::list()
[17:29:48.690]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:48.690]     if (FALSE) {
[17:29:48.690]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:48.690]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:48.690]     }
[17:29:48.690]     ...future.result <- base::tryCatch({
[17:29:48.690]         base::withCallingHandlers({
[17:29:48.690]             ...future.value <- base::withVisible(base::local({
[17:29:48.690]                 ...future.makeSendCondition <- base::local({
[17:29:48.690]                   sendCondition <- NULL
[17:29:48.690]                   function(frame = 1L) {
[17:29:48.690]                     if (is.function(sendCondition)) 
[17:29:48.690]                       return(sendCondition)
[17:29:48.690]                     ns <- getNamespace("parallel")
[17:29:48.690]                     if (exists("sendData", mode = "function", 
[17:29:48.690]                       envir = ns)) {
[17:29:48.690]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:48.690]                         envir = ns)
[17:29:48.690]                       envir <- sys.frame(frame)
[17:29:48.690]                       master <- NULL
[17:29:48.690]                       while (!identical(envir, .GlobalEnv) && 
[17:29:48.690]                         !identical(envir, emptyenv())) {
[17:29:48.690]                         if (exists("master", mode = "list", envir = envir, 
[17:29:48.690]                           inherits = FALSE)) {
[17:29:48.690]                           master <- get("master", mode = "list", 
[17:29:48.690]                             envir = envir, inherits = FALSE)
[17:29:48.690]                           if (inherits(master, c("SOCKnode", 
[17:29:48.690]                             "SOCK0node"))) {
[17:29:48.690]                             sendCondition <<- function(cond) {
[17:29:48.690]                               data <- list(type = "VALUE", value = cond, 
[17:29:48.690]                                 success = TRUE)
[17:29:48.690]                               parallel_sendData(master, data)
[17:29:48.690]                             }
[17:29:48.690]                             return(sendCondition)
[17:29:48.690]                           }
[17:29:48.690]                         }
[17:29:48.690]                         frame <- frame + 1L
[17:29:48.690]                         envir <- sys.frame(frame)
[17:29:48.690]                       }
[17:29:48.690]                     }
[17:29:48.690]                     sendCondition <<- function(cond) NULL
[17:29:48.690]                   }
[17:29:48.690]                 })
[17:29:48.690]                 withCallingHandlers({
[17:29:48.690]                   {
[17:29:48.690]                     sample(x, size = 1L)
[17:29:48.690]                   }
[17:29:48.690]                 }, immediateCondition = function(cond) {
[17:29:48.690]                   sendCondition <- ...future.makeSendCondition()
[17:29:48.690]                   sendCondition(cond)
[17:29:48.690]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.690]                   {
[17:29:48.690]                     inherits <- base::inherits
[17:29:48.690]                     invokeRestart <- base::invokeRestart
[17:29:48.690]                     is.null <- base::is.null
[17:29:48.690]                     muffled <- FALSE
[17:29:48.690]                     if (inherits(cond, "message")) {
[17:29:48.690]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:48.690]                       if (muffled) 
[17:29:48.690]                         invokeRestart("muffleMessage")
[17:29:48.690]                     }
[17:29:48.690]                     else if (inherits(cond, "warning")) {
[17:29:48.690]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:48.690]                       if (muffled) 
[17:29:48.690]                         invokeRestart("muffleWarning")
[17:29:48.690]                     }
[17:29:48.690]                     else if (inherits(cond, "condition")) {
[17:29:48.690]                       if (!is.null(pattern)) {
[17:29:48.690]                         computeRestarts <- base::computeRestarts
[17:29:48.690]                         grepl <- base::grepl
[17:29:48.690]                         restarts <- computeRestarts(cond)
[17:29:48.690]                         for (restart in restarts) {
[17:29:48.690]                           name <- restart$name
[17:29:48.690]                           if (is.null(name)) 
[17:29:48.690]                             next
[17:29:48.690]                           if (!grepl(pattern, name)) 
[17:29:48.690]                             next
[17:29:48.690]                           invokeRestart(restart)
[17:29:48.690]                           muffled <- TRUE
[17:29:48.690]                           break
[17:29:48.690]                         }
[17:29:48.690]                       }
[17:29:48.690]                     }
[17:29:48.690]                     invisible(muffled)
[17:29:48.690]                   }
[17:29:48.690]                   muffleCondition(cond)
[17:29:48.690]                 })
[17:29:48.690]             }))
[17:29:48.690]             future::FutureResult(value = ...future.value$value, 
[17:29:48.690]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.690]                   ...future.rng), globalenv = if (FALSE) 
[17:29:48.690]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:48.690]                     ...future.globalenv.names))
[17:29:48.690]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:48.690]         }, condition = base::local({
[17:29:48.690]             c <- base::c
[17:29:48.690]             inherits <- base::inherits
[17:29:48.690]             invokeRestart <- base::invokeRestart
[17:29:48.690]             length <- base::length
[17:29:48.690]             list <- base::list
[17:29:48.690]             seq.int <- base::seq.int
[17:29:48.690]             signalCondition <- base::signalCondition
[17:29:48.690]             sys.calls <- base::sys.calls
[17:29:48.690]             `[[` <- base::`[[`
[17:29:48.690]             `+` <- base::`+`
[17:29:48.690]             `<<-` <- base::`<<-`
[17:29:48.690]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:48.690]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:48.690]                   3L)]
[17:29:48.690]             }
[17:29:48.690]             function(cond) {
[17:29:48.690]                 is_error <- inherits(cond, "error")
[17:29:48.690]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:48.690]                   NULL)
[17:29:48.690]                 if (is_error) {
[17:29:48.690]                   sessionInformation <- function() {
[17:29:48.690]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:48.690]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:48.690]                       search = base::search(), system = base::Sys.info())
[17:29:48.690]                   }
[17:29:48.690]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.690]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:48.690]                     cond$call), session = sessionInformation(), 
[17:29:48.690]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:48.690]                   signalCondition(cond)
[17:29:48.690]                 }
[17:29:48.690]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:48.690]                 "immediateCondition"))) {
[17:29:48.690]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:48.690]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.690]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:48.690]                   if (TRUE && !signal) {
[17:29:48.690]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.690]                     {
[17:29:48.690]                       inherits <- base::inherits
[17:29:48.690]                       invokeRestart <- base::invokeRestart
[17:29:48.690]                       is.null <- base::is.null
[17:29:48.690]                       muffled <- FALSE
[17:29:48.690]                       if (inherits(cond, "message")) {
[17:29:48.690]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.690]                         if (muffled) 
[17:29:48.690]                           invokeRestart("muffleMessage")
[17:29:48.690]                       }
[17:29:48.690]                       else if (inherits(cond, "warning")) {
[17:29:48.690]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.690]                         if (muffled) 
[17:29:48.690]                           invokeRestart("muffleWarning")
[17:29:48.690]                       }
[17:29:48.690]                       else if (inherits(cond, "condition")) {
[17:29:48.690]                         if (!is.null(pattern)) {
[17:29:48.690]                           computeRestarts <- base::computeRestarts
[17:29:48.690]                           grepl <- base::grepl
[17:29:48.690]                           restarts <- computeRestarts(cond)
[17:29:48.690]                           for (restart in restarts) {
[17:29:48.690]                             name <- restart$name
[17:29:48.690]                             if (is.null(name)) 
[17:29:48.690]                               next
[17:29:48.690]                             if (!grepl(pattern, name)) 
[17:29:48.690]                               next
[17:29:48.690]                             invokeRestart(restart)
[17:29:48.690]                             muffled <- TRUE
[17:29:48.690]                             break
[17:29:48.690]                           }
[17:29:48.690]                         }
[17:29:48.690]                       }
[17:29:48.690]                       invisible(muffled)
[17:29:48.690]                     }
[17:29:48.690]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.690]                   }
[17:29:48.690]                 }
[17:29:48.690]                 else {
[17:29:48.690]                   if (TRUE) {
[17:29:48.690]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.690]                     {
[17:29:48.690]                       inherits <- base::inherits
[17:29:48.690]                       invokeRestart <- base::invokeRestart
[17:29:48.690]                       is.null <- base::is.null
[17:29:48.690]                       muffled <- FALSE
[17:29:48.690]                       if (inherits(cond, "message")) {
[17:29:48.690]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.690]                         if (muffled) 
[17:29:48.690]                           invokeRestart("muffleMessage")
[17:29:48.690]                       }
[17:29:48.690]                       else if (inherits(cond, "warning")) {
[17:29:48.690]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.690]                         if (muffled) 
[17:29:48.690]                           invokeRestart("muffleWarning")
[17:29:48.690]                       }
[17:29:48.690]                       else if (inherits(cond, "condition")) {
[17:29:48.690]                         if (!is.null(pattern)) {
[17:29:48.690]                           computeRestarts <- base::computeRestarts
[17:29:48.690]                           grepl <- base::grepl
[17:29:48.690]                           restarts <- computeRestarts(cond)
[17:29:48.690]                           for (restart in restarts) {
[17:29:48.690]                             name <- restart$name
[17:29:48.690]                             if (is.null(name)) 
[17:29:48.690]                               next
[17:29:48.690]                             if (!grepl(pattern, name)) 
[17:29:48.690]                               next
[17:29:48.690]                             invokeRestart(restart)
[17:29:48.690]                             muffled <- TRUE
[17:29:48.690]                             break
[17:29:48.690]                           }
[17:29:48.690]                         }
[17:29:48.690]                       }
[17:29:48.690]                       invisible(muffled)
[17:29:48.690]                     }
[17:29:48.690]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.690]                   }
[17:29:48.690]                 }
[17:29:48.690]             }
[17:29:48.690]         }))
[17:29:48.690]     }, error = function(ex) {
[17:29:48.690]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:48.690]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.690]                 ...future.rng), started = ...future.startTime, 
[17:29:48.690]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:48.690]             version = "1.8"), class = "FutureResult")
[17:29:48.690]     }, finally = {
[17:29:48.690]         if (!identical(...future.workdir, getwd())) 
[17:29:48.690]             setwd(...future.workdir)
[17:29:48.690]         {
[17:29:48.690]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:48.690]                 ...future.oldOptions$nwarnings <- NULL
[17:29:48.690]             }
[17:29:48.690]             base::options(...future.oldOptions)
[17:29:48.690]             if (.Platform$OS.type == "windows") {
[17:29:48.690]                 old_names <- names(...future.oldEnvVars)
[17:29:48.690]                 envs <- base::Sys.getenv()
[17:29:48.690]                 names <- names(envs)
[17:29:48.690]                 common <- intersect(names, old_names)
[17:29:48.690]                 added <- setdiff(names, old_names)
[17:29:48.690]                 removed <- setdiff(old_names, names)
[17:29:48.690]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:48.690]                   envs[common]]
[17:29:48.690]                 NAMES <- toupper(changed)
[17:29:48.690]                 args <- list()
[17:29:48.690]                 for (kk in seq_along(NAMES)) {
[17:29:48.690]                   name <- changed[[kk]]
[17:29:48.690]                   NAME <- NAMES[[kk]]
[17:29:48.690]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.690]                     next
[17:29:48.690]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.690]                 }
[17:29:48.690]                 NAMES <- toupper(added)
[17:29:48.690]                 for (kk in seq_along(NAMES)) {
[17:29:48.690]                   name <- added[[kk]]
[17:29:48.690]                   NAME <- NAMES[[kk]]
[17:29:48.690]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.690]                     next
[17:29:48.690]                   args[[name]] <- ""
[17:29:48.690]                 }
[17:29:48.690]                 NAMES <- toupper(removed)
[17:29:48.690]                 for (kk in seq_along(NAMES)) {
[17:29:48.690]                   name <- removed[[kk]]
[17:29:48.690]                   NAME <- NAMES[[kk]]
[17:29:48.690]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.690]                     next
[17:29:48.690]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.690]                 }
[17:29:48.690]                 if (length(args) > 0) 
[17:29:48.690]                   base::do.call(base::Sys.setenv, args = args)
[17:29:48.690]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:48.690]             }
[17:29:48.690]             else {
[17:29:48.690]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:48.690]             }
[17:29:48.690]             {
[17:29:48.690]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:48.690]                   0L) {
[17:29:48.690]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:48.690]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:48.690]                   base::options(opts)
[17:29:48.690]                 }
[17:29:48.690]                 {
[17:29:48.690]                   {
[17:29:48.690]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:48.690]                     NULL
[17:29:48.690]                   }
[17:29:48.690]                   options(future.plan = NULL)
[17:29:48.690]                   if (is.na(NA_character_)) 
[17:29:48.690]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.690]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:48.690]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:48.690]                     .init = FALSE)
[17:29:48.690]                 }
[17:29:48.690]             }
[17:29:48.690]         }
[17:29:48.690]     })
[17:29:48.690]     if (TRUE) {
[17:29:48.690]         base::sink(type = "output", split = FALSE)
[17:29:48.690]         if (TRUE) {
[17:29:48.690]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:48.690]         }
[17:29:48.690]         else {
[17:29:48.690]             ...future.result["stdout"] <- base::list(NULL)
[17:29:48.690]         }
[17:29:48.690]         base::close(...future.stdout)
[17:29:48.690]         ...future.stdout <- NULL
[17:29:48.690]     }
[17:29:48.690]     ...future.result$conditions <- ...future.conditions
[17:29:48.690]     ...future.result$finished <- base::Sys.time()
[17:29:48.690]     ...future.result
[17:29:48.690] }
[17:29:48.696] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:48.723] receiveMessageFromWorker() for ClusterFuture ...
[17:29:48.723] - Validating connection of MultisessionFuture
[17:29:48.723] - received message: FutureResult
[17:29:48.724] - Received FutureResult
[17:29:48.724] - Erased future from FutureRegistry
[17:29:48.724] result() for ClusterFuture ...
[17:29:48.724] - result already collected: FutureResult
[17:29:48.724] result() for ClusterFuture ... done
[17:29:48.725] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:48.725] result() for ClusterFuture ...
[17:29:48.725] - result already collected: FutureResult
[17:29:48.725] result() for ClusterFuture ... done
[17:29:48.726] result() for ClusterFuture ...
[17:29:48.726] - result already collected: FutureResult
[17:29:48.726] result() for ClusterFuture ... done
[17:29:48.728] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:48.728] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:48.728] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:48.729] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:48.730] MultisessionFuture started
[17:29:48.730] - Launch lazy future ... done
[17:29:48.730] run() for 'MultisessionFuture' ... done
[17:29:48.731] getGlobalsAndPackages() ...
[17:29:48.731] Searching for globals...
[17:29:48.733] - globals found: [3] '{', 'sample', 'x'
[17:29:48.733] Searching for globals ... DONE
[17:29:48.734] Resolving globals: FALSE
[17:29:48.734] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:48.735] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:48.735] - globals: [1] 'x'
[17:29:48.735] 
[17:29:48.736] getGlobalsAndPackages() ... DONE
[17:29:48.736] run() for 'Future' ...
[17:29:48.736] - state: 'created'
[17:29:48.736] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:48.753] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:48.753] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:48.753]   - Field: 'node'
[17:29:48.753]   - Field: 'label'
[17:29:48.754]   - Field: 'local'
[17:29:48.754]   - Field: 'owner'
[17:29:48.754]   - Field: 'envir'
[17:29:48.755]   - Field: 'workers'
[17:29:48.755]   - Field: 'packages'
[17:29:48.755]   - Field: 'gc'
[17:29:48.756]   - Field: 'conditions'
[17:29:48.756]   - Field: 'persistent'
[17:29:48.756]   - Field: 'expr'
[17:29:48.757]   - Field: 'uuid'
[17:29:48.757]   - Field: 'seed'
[17:29:48.757]   - Field: 'version'
[17:29:48.758]   - Field: 'result'
[17:29:48.758]   - Field: 'asynchronous'
[17:29:48.758]   - Field: 'calls'
[17:29:48.759]   - Field: 'globals'
[17:29:48.759]   - Field: 'stdout'
[17:29:48.759]   - Field: 'earlySignal'
[17:29:48.760]   - Field: 'lazy'
[17:29:48.760]   - Field: 'state'
[17:29:48.760] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:48.761] - Launch lazy future ...
[17:29:48.761] Packages needed by the future expression (n = 0): <none>
[17:29:48.762] Packages needed by future strategies (n = 0): <none>
[17:29:48.763] {
[17:29:48.763]     {
[17:29:48.763]         {
[17:29:48.763]             ...future.startTime <- base::Sys.time()
[17:29:48.763]             {
[17:29:48.763]                 {
[17:29:48.763]                   {
[17:29:48.763]                     {
[17:29:48.763]                       base::local({
[17:29:48.763]                         has_future <- base::requireNamespace("future", 
[17:29:48.763]                           quietly = TRUE)
[17:29:48.763]                         if (has_future) {
[17:29:48.763]                           ns <- base::getNamespace("future")
[17:29:48.763]                           version <- ns[[".package"]][["version"]]
[17:29:48.763]                           if (is.null(version)) 
[17:29:48.763]                             version <- utils::packageVersion("future")
[17:29:48.763]                         }
[17:29:48.763]                         else {
[17:29:48.763]                           version <- NULL
[17:29:48.763]                         }
[17:29:48.763]                         if (!has_future || version < "1.8.0") {
[17:29:48.763]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:48.763]                             "", base::R.version$version.string), 
[17:29:48.763]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:48.763]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:48.763]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:48.763]                               "release", "version")], collapse = " "), 
[17:29:48.763]                             hostname = base::Sys.info()[["nodename"]])
[17:29:48.763]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:48.763]                             info)
[17:29:48.763]                           info <- base::paste(info, collapse = "; ")
[17:29:48.763]                           if (!has_future) {
[17:29:48.763]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:48.763]                               info)
[17:29:48.763]                           }
[17:29:48.763]                           else {
[17:29:48.763]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:48.763]                               info, version)
[17:29:48.763]                           }
[17:29:48.763]                           base::stop(msg)
[17:29:48.763]                         }
[17:29:48.763]                       })
[17:29:48.763]                     }
[17:29:48.763]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:48.763]                     base::options(mc.cores = 1L)
[17:29:48.763]                   }
[17:29:48.763]                   ...future.strategy.old <- future::plan("list")
[17:29:48.763]                   options(future.plan = NULL)
[17:29:48.763]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.763]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:48.763]                 }
[17:29:48.763]                 ...future.workdir <- getwd()
[17:29:48.763]             }
[17:29:48.763]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:48.763]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:48.763]         }
[17:29:48.763]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:48.763]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:48.763]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:48.763]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:48.763]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:48.763]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:48.763]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:48.763]             base::names(...future.oldOptions))
[17:29:48.763]     }
[17:29:48.763]     if (FALSE) {
[17:29:48.763]     }
[17:29:48.763]     else {
[17:29:48.763]         if (TRUE) {
[17:29:48.763]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:48.763]                 open = "w")
[17:29:48.763]         }
[17:29:48.763]         else {
[17:29:48.763]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:48.763]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:48.763]         }
[17:29:48.763]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:48.763]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:48.763]             base::sink(type = "output", split = FALSE)
[17:29:48.763]             base::close(...future.stdout)
[17:29:48.763]         }, add = TRUE)
[17:29:48.763]     }
[17:29:48.763]     ...future.frame <- base::sys.nframe()
[17:29:48.763]     ...future.conditions <- base::list()
[17:29:48.763]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:48.763]     if (FALSE) {
[17:29:48.763]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:48.763]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:48.763]     }
[17:29:48.763]     ...future.result <- base::tryCatch({
[17:29:48.763]         base::withCallingHandlers({
[17:29:48.763]             ...future.value <- base::withVisible(base::local({
[17:29:48.763]                 ...future.makeSendCondition <- base::local({
[17:29:48.763]                   sendCondition <- NULL
[17:29:48.763]                   function(frame = 1L) {
[17:29:48.763]                     if (is.function(sendCondition)) 
[17:29:48.763]                       return(sendCondition)
[17:29:48.763]                     ns <- getNamespace("parallel")
[17:29:48.763]                     if (exists("sendData", mode = "function", 
[17:29:48.763]                       envir = ns)) {
[17:29:48.763]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:48.763]                         envir = ns)
[17:29:48.763]                       envir <- sys.frame(frame)
[17:29:48.763]                       master <- NULL
[17:29:48.763]                       while (!identical(envir, .GlobalEnv) && 
[17:29:48.763]                         !identical(envir, emptyenv())) {
[17:29:48.763]                         if (exists("master", mode = "list", envir = envir, 
[17:29:48.763]                           inherits = FALSE)) {
[17:29:48.763]                           master <- get("master", mode = "list", 
[17:29:48.763]                             envir = envir, inherits = FALSE)
[17:29:48.763]                           if (inherits(master, c("SOCKnode", 
[17:29:48.763]                             "SOCK0node"))) {
[17:29:48.763]                             sendCondition <<- function(cond) {
[17:29:48.763]                               data <- list(type = "VALUE", value = cond, 
[17:29:48.763]                                 success = TRUE)
[17:29:48.763]                               parallel_sendData(master, data)
[17:29:48.763]                             }
[17:29:48.763]                             return(sendCondition)
[17:29:48.763]                           }
[17:29:48.763]                         }
[17:29:48.763]                         frame <- frame + 1L
[17:29:48.763]                         envir <- sys.frame(frame)
[17:29:48.763]                       }
[17:29:48.763]                     }
[17:29:48.763]                     sendCondition <<- function(cond) NULL
[17:29:48.763]                   }
[17:29:48.763]                 })
[17:29:48.763]                 withCallingHandlers({
[17:29:48.763]                   {
[17:29:48.763]                     sample(x, size = 1L)
[17:29:48.763]                   }
[17:29:48.763]                 }, immediateCondition = function(cond) {
[17:29:48.763]                   sendCondition <- ...future.makeSendCondition()
[17:29:48.763]                   sendCondition(cond)
[17:29:48.763]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.763]                   {
[17:29:48.763]                     inherits <- base::inherits
[17:29:48.763]                     invokeRestart <- base::invokeRestart
[17:29:48.763]                     is.null <- base::is.null
[17:29:48.763]                     muffled <- FALSE
[17:29:48.763]                     if (inherits(cond, "message")) {
[17:29:48.763]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:48.763]                       if (muffled) 
[17:29:48.763]                         invokeRestart("muffleMessage")
[17:29:48.763]                     }
[17:29:48.763]                     else if (inherits(cond, "warning")) {
[17:29:48.763]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:48.763]                       if (muffled) 
[17:29:48.763]                         invokeRestart("muffleWarning")
[17:29:48.763]                     }
[17:29:48.763]                     else if (inherits(cond, "condition")) {
[17:29:48.763]                       if (!is.null(pattern)) {
[17:29:48.763]                         computeRestarts <- base::computeRestarts
[17:29:48.763]                         grepl <- base::grepl
[17:29:48.763]                         restarts <- computeRestarts(cond)
[17:29:48.763]                         for (restart in restarts) {
[17:29:48.763]                           name <- restart$name
[17:29:48.763]                           if (is.null(name)) 
[17:29:48.763]                             next
[17:29:48.763]                           if (!grepl(pattern, name)) 
[17:29:48.763]                             next
[17:29:48.763]                           invokeRestart(restart)
[17:29:48.763]                           muffled <- TRUE
[17:29:48.763]                           break
[17:29:48.763]                         }
[17:29:48.763]                       }
[17:29:48.763]                     }
[17:29:48.763]                     invisible(muffled)
[17:29:48.763]                   }
[17:29:48.763]                   muffleCondition(cond)
[17:29:48.763]                 })
[17:29:48.763]             }))
[17:29:48.763]             future::FutureResult(value = ...future.value$value, 
[17:29:48.763]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.763]                   ...future.rng), globalenv = if (FALSE) 
[17:29:48.763]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:48.763]                     ...future.globalenv.names))
[17:29:48.763]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:48.763]         }, condition = base::local({
[17:29:48.763]             c <- base::c
[17:29:48.763]             inherits <- base::inherits
[17:29:48.763]             invokeRestart <- base::invokeRestart
[17:29:48.763]             length <- base::length
[17:29:48.763]             list <- base::list
[17:29:48.763]             seq.int <- base::seq.int
[17:29:48.763]             signalCondition <- base::signalCondition
[17:29:48.763]             sys.calls <- base::sys.calls
[17:29:48.763]             `[[` <- base::`[[`
[17:29:48.763]             `+` <- base::`+`
[17:29:48.763]             `<<-` <- base::`<<-`
[17:29:48.763]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:48.763]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:48.763]                   3L)]
[17:29:48.763]             }
[17:29:48.763]             function(cond) {
[17:29:48.763]                 is_error <- inherits(cond, "error")
[17:29:48.763]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:48.763]                   NULL)
[17:29:48.763]                 if (is_error) {
[17:29:48.763]                   sessionInformation <- function() {
[17:29:48.763]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:48.763]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:48.763]                       search = base::search(), system = base::Sys.info())
[17:29:48.763]                   }
[17:29:48.763]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.763]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:48.763]                     cond$call), session = sessionInformation(), 
[17:29:48.763]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:48.763]                   signalCondition(cond)
[17:29:48.763]                 }
[17:29:48.763]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:48.763]                 "immediateCondition"))) {
[17:29:48.763]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:48.763]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.763]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:48.763]                   if (TRUE && !signal) {
[17:29:48.763]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.763]                     {
[17:29:48.763]                       inherits <- base::inherits
[17:29:48.763]                       invokeRestart <- base::invokeRestart
[17:29:48.763]                       is.null <- base::is.null
[17:29:48.763]                       muffled <- FALSE
[17:29:48.763]                       if (inherits(cond, "message")) {
[17:29:48.763]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.763]                         if (muffled) 
[17:29:48.763]                           invokeRestart("muffleMessage")
[17:29:48.763]                       }
[17:29:48.763]                       else if (inherits(cond, "warning")) {
[17:29:48.763]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.763]                         if (muffled) 
[17:29:48.763]                           invokeRestart("muffleWarning")
[17:29:48.763]                       }
[17:29:48.763]                       else if (inherits(cond, "condition")) {
[17:29:48.763]                         if (!is.null(pattern)) {
[17:29:48.763]                           computeRestarts <- base::computeRestarts
[17:29:48.763]                           grepl <- base::grepl
[17:29:48.763]                           restarts <- computeRestarts(cond)
[17:29:48.763]                           for (restart in restarts) {
[17:29:48.763]                             name <- restart$name
[17:29:48.763]                             if (is.null(name)) 
[17:29:48.763]                               next
[17:29:48.763]                             if (!grepl(pattern, name)) 
[17:29:48.763]                               next
[17:29:48.763]                             invokeRestart(restart)
[17:29:48.763]                             muffled <- TRUE
[17:29:48.763]                             break
[17:29:48.763]                           }
[17:29:48.763]                         }
[17:29:48.763]                       }
[17:29:48.763]                       invisible(muffled)
[17:29:48.763]                     }
[17:29:48.763]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.763]                   }
[17:29:48.763]                 }
[17:29:48.763]                 else {
[17:29:48.763]                   if (TRUE) {
[17:29:48.763]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.763]                     {
[17:29:48.763]                       inherits <- base::inherits
[17:29:48.763]                       invokeRestart <- base::invokeRestart
[17:29:48.763]                       is.null <- base::is.null
[17:29:48.763]                       muffled <- FALSE
[17:29:48.763]                       if (inherits(cond, "message")) {
[17:29:48.763]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.763]                         if (muffled) 
[17:29:48.763]                           invokeRestart("muffleMessage")
[17:29:48.763]                       }
[17:29:48.763]                       else if (inherits(cond, "warning")) {
[17:29:48.763]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.763]                         if (muffled) 
[17:29:48.763]                           invokeRestart("muffleWarning")
[17:29:48.763]                       }
[17:29:48.763]                       else if (inherits(cond, "condition")) {
[17:29:48.763]                         if (!is.null(pattern)) {
[17:29:48.763]                           computeRestarts <- base::computeRestarts
[17:29:48.763]                           grepl <- base::grepl
[17:29:48.763]                           restarts <- computeRestarts(cond)
[17:29:48.763]                           for (restart in restarts) {
[17:29:48.763]                             name <- restart$name
[17:29:48.763]                             if (is.null(name)) 
[17:29:48.763]                               next
[17:29:48.763]                             if (!grepl(pattern, name)) 
[17:29:48.763]                               next
[17:29:48.763]                             invokeRestart(restart)
[17:29:48.763]                             muffled <- TRUE
[17:29:48.763]                             break
[17:29:48.763]                           }
[17:29:48.763]                         }
[17:29:48.763]                       }
[17:29:48.763]                       invisible(muffled)
[17:29:48.763]                     }
[17:29:48.763]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.763]                   }
[17:29:48.763]                 }
[17:29:48.763]             }
[17:29:48.763]         }))
[17:29:48.763]     }, error = function(ex) {
[17:29:48.763]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:48.763]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.763]                 ...future.rng), started = ...future.startTime, 
[17:29:48.763]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:48.763]             version = "1.8"), class = "FutureResult")
[17:29:48.763]     }, finally = {
[17:29:48.763]         if (!identical(...future.workdir, getwd())) 
[17:29:48.763]             setwd(...future.workdir)
[17:29:48.763]         {
[17:29:48.763]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:48.763]                 ...future.oldOptions$nwarnings <- NULL
[17:29:48.763]             }
[17:29:48.763]             base::options(...future.oldOptions)
[17:29:48.763]             if (.Platform$OS.type == "windows") {
[17:29:48.763]                 old_names <- names(...future.oldEnvVars)
[17:29:48.763]                 envs <- base::Sys.getenv()
[17:29:48.763]                 names <- names(envs)
[17:29:48.763]                 common <- intersect(names, old_names)
[17:29:48.763]                 added <- setdiff(names, old_names)
[17:29:48.763]                 removed <- setdiff(old_names, names)
[17:29:48.763]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:48.763]                   envs[common]]
[17:29:48.763]                 NAMES <- toupper(changed)
[17:29:48.763]                 args <- list()
[17:29:48.763]                 for (kk in seq_along(NAMES)) {
[17:29:48.763]                   name <- changed[[kk]]
[17:29:48.763]                   NAME <- NAMES[[kk]]
[17:29:48.763]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.763]                     next
[17:29:48.763]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.763]                 }
[17:29:48.763]                 NAMES <- toupper(added)
[17:29:48.763]                 for (kk in seq_along(NAMES)) {
[17:29:48.763]                   name <- added[[kk]]
[17:29:48.763]                   NAME <- NAMES[[kk]]
[17:29:48.763]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.763]                     next
[17:29:48.763]                   args[[name]] <- ""
[17:29:48.763]                 }
[17:29:48.763]                 NAMES <- toupper(removed)
[17:29:48.763]                 for (kk in seq_along(NAMES)) {
[17:29:48.763]                   name <- removed[[kk]]
[17:29:48.763]                   NAME <- NAMES[[kk]]
[17:29:48.763]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.763]                     next
[17:29:48.763]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.763]                 }
[17:29:48.763]                 if (length(args) > 0) 
[17:29:48.763]                   base::do.call(base::Sys.setenv, args = args)
[17:29:48.763]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:48.763]             }
[17:29:48.763]             else {
[17:29:48.763]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:48.763]             }
[17:29:48.763]             {
[17:29:48.763]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:48.763]                   0L) {
[17:29:48.763]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:48.763]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:48.763]                   base::options(opts)
[17:29:48.763]                 }
[17:29:48.763]                 {
[17:29:48.763]                   {
[17:29:48.763]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:48.763]                     NULL
[17:29:48.763]                   }
[17:29:48.763]                   options(future.plan = NULL)
[17:29:48.763]                   if (is.na(NA_character_)) 
[17:29:48.763]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.763]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:48.763]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:48.763]                     .init = FALSE)
[17:29:48.763]                 }
[17:29:48.763]             }
[17:29:48.763]         }
[17:29:48.763]     })
[17:29:48.763]     if (TRUE) {
[17:29:48.763]         base::sink(type = "output", split = FALSE)
[17:29:48.763]         if (TRUE) {
[17:29:48.763]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:48.763]         }
[17:29:48.763]         else {
[17:29:48.763]             ...future.result["stdout"] <- base::list(NULL)
[17:29:48.763]         }
[17:29:48.763]         base::close(...future.stdout)
[17:29:48.763]         ...future.stdout <- NULL
[17:29:48.763]     }
[17:29:48.763]     ...future.result$conditions <- ...future.conditions
[17:29:48.763]     ...future.result$finished <- base::Sys.time()
[17:29:48.763]     ...future.result
[17:29:48.763] }
[17:29:48.771] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:48.785] receiveMessageFromWorker() for ClusterFuture ...
[17:29:48.786] - Validating connection of MultisessionFuture
[17:29:48.786] - received message: FutureResult
[17:29:48.786] - Received FutureResult
[17:29:48.787] - Erased future from FutureRegistry
[17:29:48.787] result() for ClusterFuture ...
[17:29:48.787] - result already collected: FutureResult
[17:29:48.788] result() for ClusterFuture ... done
[17:29:48.788] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:48.788] result() for ClusterFuture ...
[17:29:48.789] - result already collected: FutureResult
[17:29:48.789] result() for ClusterFuture ... done
[17:29:48.789] result() for ClusterFuture ...
[17:29:48.790] - result already collected: FutureResult
[17:29:48.790] result() for ClusterFuture ... done
[17:29:48.792] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:48.792] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:48.793] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:48.793] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:48.794] MultisessionFuture started
[17:29:48.794] - Launch lazy future ... done
[17:29:48.795] run() for 'MultisessionFuture' ... done
[17:29:48.796] getGlobalsAndPackages() ...
[17:29:48.796] Searching for globals...
[17:29:48.798] - globals found: [3] '{', 'sample', 'x'
[17:29:48.799] Searching for globals ... DONE
[17:29:48.799] Resolving globals: FALSE
[17:29:48.800] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:48.801] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:48.801] - globals: [1] 'x'
[17:29:48.801] 
[17:29:48.801] getGlobalsAndPackages() ... DONE
[17:29:48.802] run() for 'Future' ...
[17:29:48.802] - state: 'created'
[17:29:48.803] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:48.824] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:48.825] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:48.825]   - Field: 'node'
[17:29:48.825]   - Field: 'label'
[17:29:48.826]   - Field: 'local'
[17:29:48.826]   - Field: 'owner'
[17:29:48.826]   - Field: 'envir'
[17:29:48.827]   - Field: 'workers'
[17:29:48.827]   - Field: 'packages'
[17:29:48.827]   - Field: 'gc'
[17:29:48.828]   - Field: 'conditions'
[17:29:48.828]   - Field: 'persistent'
[17:29:48.828]   - Field: 'expr'
[17:29:48.828]   - Field: 'uuid'
[17:29:48.829]   - Field: 'seed'
[17:29:48.829]   - Field: 'version'
[17:29:48.829]   - Field: 'result'
[17:29:48.830]   - Field: 'asynchronous'
[17:29:48.830]   - Field: 'calls'
[17:29:48.830]   - Field: 'globals'
[17:29:48.831]   - Field: 'stdout'
[17:29:48.831]   - Field: 'earlySignal'
[17:29:48.831]   - Field: 'lazy'
[17:29:48.832]   - Field: 'state'
[17:29:48.832] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:48.832] - Launch lazy future ...
[17:29:48.833] Packages needed by the future expression (n = 0): <none>
[17:29:48.833] Packages needed by future strategies (n = 0): <none>
[17:29:48.834] {
[17:29:48.834]     {
[17:29:48.834]         {
[17:29:48.834]             ...future.startTime <- base::Sys.time()
[17:29:48.834]             {
[17:29:48.834]                 {
[17:29:48.834]                   {
[17:29:48.834]                     {
[17:29:48.834]                       base::local({
[17:29:48.834]                         has_future <- base::requireNamespace("future", 
[17:29:48.834]                           quietly = TRUE)
[17:29:48.834]                         if (has_future) {
[17:29:48.834]                           ns <- base::getNamespace("future")
[17:29:48.834]                           version <- ns[[".package"]][["version"]]
[17:29:48.834]                           if (is.null(version)) 
[17:29:48.834]                             version <- utils::packageVersion("future")
[17:29:48.834]                         }
[17:29:48.834]                         else {
[17:29:48.834]                           version <- NULL
[17:29:48.834]                         }
[17:29:48.834]                         if (!has_future || version < "1.8.0") {
[17:29:48.834]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:48.834]                             "", base::R.version$version.string), 
[17:29:48.834]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:48.834]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:48.834]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:48.834]                               "release", "version")], collapse = " "), 
[17:29:48.834]                             hostname = base::Sys.info()[["nodename"]])
[17:29:48.834]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:48.834]                             info)
[17:29:48.834]                           info <- base::paste(info, collapse = "; ")
[17:29:48.834]                           if (!has_future) {
[17:29:48.834]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:48.834]                               info)
[17:29:48.834]                           }
[17:29:48.834]                           else {
[17:29:48.834]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:48.834]                               info, version)
[17:29:48.834]                           }
[17:29:48.834]                           base::stop(msg)
[17:29:48.834]                         }
[17:29:48.834]                       })
[17:29:48.834]                     }
[17:29:48.834]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:48.834]                     base::options(mc.cores = 1L)
[17:29:48.834]                   }
[17:29:48.834]                   ...future.strategy.old <- future::plan("list")
[17:29:48.834]                   options(future.plan = NULL)
[17:29:48.834]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.834]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:48.834]                 }
[17:29:48.834]                 ...future.workdir <- getwd()
[17:29:48.834]             }
[17:29:48.834]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:48.834]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:48.834]         }
[17:29:48.834]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:48.834]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:48.834]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:48.834]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:48.834]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:48.834]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:48.834]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:48.834]             base::names(...future.oldOptions))
[17:29:48.834]     }
[17:29:48.834]     if (FALSE) {
[17:29:48.834]     }
[17:29:48.834]     else {
[17:29:48.834]         if (TRUE) {
[17:29:48.834]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:48.834]                 open = "w")
[17:29:48.834]         }
[17:29:48.834]         else {
[17:29:48.834]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:48.834]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:48.834]         }
[17:29:48.834]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:48.834]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:48.834]             base::sink(type = "output", split = FALSE)
[17:29:48.834]             base::close(...future.stdout)
[17:29:48.834]         }, add = TRUE)
[17:29:48.834]     }
[17:29:48.834]     ...future.frame <- base::sys.nframe()
[17:29:48.834]     ...future.conditions <- base::list()
[17:29:48.834]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:48.834]     if (FALSE) {
[17:29:48.834]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:48.834]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:48.834]     }
[17:29:48.834]     ...future.result <- base::tryCatch({
[17:29:48.834]         base::withCallingHandlers({
[17:29:48.834]             ...future.value <- base::withVisible(base::local({
[17:29:48.834]                 ...future.makeSendCondition <- base::local({
[17:29:48.834]                   sendCondition <- NULL
[17:29:48.834]                   function(frame = 1L) {
[17:29:48.834]                     if (is.function(sendCondition)) 
[17:29:48.834]                       return(sendCondition)
[17:29:48.834]                     ns <- getNamespace("parallel")
[17:29:48.834]                     if (exists("sendData", mode = "function", 
[17:29:48.834]                       envir = ns)) {
[17:29:48.834]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:48.834]                         envir = ns)
[17:29:48.834]                       envir <- sys.frame(frame)
[17:29:48.834]                       master <- NULL
[17:29:48.834]                       while (!identical(envir, .GlobalEnv) && 
[17:29:48.834]                         !identical(envir, emptyenv())) {
[17:29:48.834]                         if (exists("master", mode = "list", envir = envir, 
[17:29:48.834]                           inherits = FALSE)) {
[17:29:48.834]                           master <- get("master", mode = "list", 
[17:29:48.834]                             envir = envir, inherits = FALSE)
[17:29:48.834]                           if (inherits(master, c("SOCKnode", 
[17:29:48.834]                             "SOCK0node"))) {
[17:29:48.834]                             sendCondition <<- function(cond) {
[17:29:48.834]                               data <- list(type = "VALUE", value = cond, 
[17:29:48.834]                                 success = TRUE)
[17:29:48.834]                               parallel_sendData(master, data)
[17:29:48.834]                             }
[17:29:48.834]                             return(sendCondition)
[17:29:48.834]                           }
[17:29:48.834]                         }
[17:29:48.834]                         frame <- frame + 1L
[17:29:48.834]                         envir <- sys.frame(frame)
[17:29:48.834]                       }
[17:29:48.834]                     }
[17:29:48.834]                     sendCondition <<- function(cond) NULL
[17:29:48.834]                   }
[17:29:48.834]                 })
[17:29:48.834]                 withCallingHandlers({
[17:29:48.834]                   {
[17:29:48.834]                     sample(x, size = 1L)
[17:29:48.834]                   }
[17:29:48.834]                 }, immediateCondition = function(cond) {
[17:29:48.834]                   sendCondition <- ...future.makeSendCondition()
[17:29:48.834]                   sendCondition(cond)
[17:29:48.834]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.834]                   {
[17:29:48.834]                     inherits <- base::inherits
[17:29:48.834]                     invokeRestart <- base::invokeRestart
[17:29:48.834]                     is.null <- base::is.null
[17:29:48.834]                     muffled <- FALSE
[17:29:48.834]                     if (inherits(cond, "message")) {
[17:29:48.834]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:48.834]                       if (muffled) 
[17:29:48.834]                         invokeRestart("muffleMessage")
[17:29:48.834]                     }
[17:29:48.834]                     else if (inherits(cond, "warning")) {
[17:29:48.834]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:48.834]                       if (muffled) 
[17:29:48.834]                         invokeRestart("muffleWarning")
[17:29:48.834]                     }
[17:29:48.834]                     else if (inherits(cond, "condition")) {
[17:29:48.834]                       if (!is.null(pattern)) {
[17:29:48.834]                         computeRestarts <- base::computeRestarts
[17:29:48.834]                         grepl <- base::grepl
[17:29:48.834]                         restarts <- computeRestarts(cond)
[17:29:48.834]                         for (restart in restarts) {
[17:29:48.834]                           name <- restart$name
[17:29:48.834]                           if (is.null(name)) 
[17:29:48.834]                             next
[17:29:48.834]                           if (!grepl(pattern, name)) 
[17:29:48.834]                             next
[17:29:48.834]                           invokeRestart(restart)
[17:29:48.834]                           muffled <- TRUE
[17:29:48.834]                           break
[17:29:48.834]                         }
[17:29:48.834]                       }
[17:29:48.834]                     }
[17:29:48.834]                     invisible(muffled)
[17:29:48.834]                   }
[17:29:48.834]                   muffleCondition(cond)
[17:29:48.834]                 })
[17:29:48.834]             }))
[17:29:48.834]             future::FutureResult(value = ...future.value$value, 
[17:29:48.834]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.834]                   ...future.rng), globalenv = if (FALSE) 
[17:29:48.834]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:48.834]                     ...future.globalenv.names))
[17:29:48.834]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:48.834]         }, condition = base::local({
[17:29:48.834]             c <- base::c
[17:29:48.834]             inherits <- base::inherits
[17:29:48.834]             invokeRestart <- base::invokeRestart
[17:29:48.834]             length <- base::length
[17:29:48.834]             list <- base::list
[17:29:48.834]             seq.int <- base::seq.int
[17:29:48.834]             signalCondition <- base::signalCondition
[17:29:48.834]             sys.calls <- base::sys.calls
[17:29:48.834]             `[[` <- base::`[[`
[17:29:48.834]             `+` <- base::`+`
[17:29:48.834]             `<<-` <- base::`<<-`
[17:29:48.834]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:48.834]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:48.834]                   3L)]
[17:29:48.834]             }
[17:29:48.834]             function(cond) {
[17:29:48.834]                 is_error <- inherits(cond, "error")
[17:29:48.834]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:48.834]                   NULL)
[17:29:48.834]                 if (is_error) {
[17:29:48.834]                   sessionInformation <- function() {
[17:29:48.834]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:48.834]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:48.834]                       search = base::search(), system = base::Sys.info())
[17:29:48.834]                   }
[17:29:48.834]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.834]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:48.834]                     cond$call), session = sessionInformation(), 
[17:29:48.834]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:48.834]                   signalCondition(cond)
[17:29:48.834]                 }
[17:29:48.834]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:48.834]                 "immediateCondition"))) {
[17:29:48.834]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:48.834]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.834]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:48.834]                   if (TRUE && !signal) {
[17:29:48.834]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.834]                     {
[17:29:48.834]                       inherits <- base::inherits
[17:29:48.834]                       invokeRestart <- base::invokeRestart
[17:29:48.834]                       is.null <- base::is.null
[17:29:48.834]                       muffled <- FALSE
[17:29:48.834]                       if (inherits(cond, "message")) {
[17:29:48.834]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.834]                         if (muffled) 
[17:29:48.834]                           invokeRestart("muffleMessage")
[17:29:48.834]                       }
[17:29:48.834]                       else if (inherits(cond, "warning")) {
[17:29:48.834]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.834]                         if (muffled) 
[17:29:48.834]                           invokeRestart("muffleWarning")
[17:29:48.834]                       }
[17:29:48.834]                       else if (inherits(cond, "condition")) {
[17:29:48.834]                         if (!is.null(pattern)) {
[17:29:48.834]                           computeRestarts <- base::computeRestarts
[17:29:48.834]                           grepl <- base::grepl
[17:29:48.834]                           restarts <- computeRestarts(cond)
[17:29:48.834]                           for (restart in restarts) {
[17:29:48.834]                             name <- restart$name
[17:29:48.834]                             if (is.null(name)) 
[17:29:48.834]                               next
[17:29:48.834]                             if (!grepl(pattern, name)) 
[17:29:48.834]                               next
[17:29:48.834]                             invokeRestart(restart)
[17:29:48.834]                             muffled <- TRUE
[17:29:48.834]                             break
[17:29:48.834]                           }
[17:29:48.834]                         }
[17:29:48.834]                       }
[17:29:48.834]                       invisible(muffled)
[17:29:48.834]                     }
[17:29:48.834]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.834]                   }
[17:29:48.834]                 }
[17:29:48.834]                 else {
[17:29:48.834]                   if (TRUE) {
[17:29:48.834]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.834]                     {
[17:29:48.834]                       inherits <- base::inherits
[17:29:48.834]                       invokeRestart <- base::invokeRestart
[17:29:48.834]                       is.null <- base::is.null
[17:29:48.834]                       muffled <- FALSE
[17:29:48.834]                       if (inherits(cond, "message")) {
[17:29:48.834]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.834]                         if (muffled) 
[17:29:48.834]                           invokeRestart("muffleMessage")
[17:29:48.834]                       }
[17:29:48.834]                       else if (inherits(cond, "warning")) {
[17:29:48.834]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.834]                         if (muffled) 
[17:29:48.834]                           invokeRestart("muffleWarning")
[17:29:48.834]                       }
[17:29:48.834]                       else if (inherits(cond, "condition")) {
[17:29:48.834]                         if (!is.null(pattern)) {
[17:29:48.834]                           computeRestarts <- base::computeRestarts
[17:29:48.834]                           grepl <- base::grepl
[17:29:48.834]                           restarts <- computeRestarts(cond)
[17:29:48.834]                           for (restart in restarts) {
[17:29:48.834]                             name <- restart$name
[17:29:48.834]                             if (is.null(name)) 
[17:29:48.834]                               next
[17:29:48.834]                             if (!grepl(pattern, name)) 
[17:29:48.834]                               next
[17:29:48.834]                             invokeRestart(restart)
[17:29:48.834]                             muffled <- TRUE
[17:29:48.834]                             break
[17:29:48.834]                           }
[17:29:48.834]                         }
[17:29:48.834]                       }
[17:29:48.834]                       invisible(muffled)
[17:29:48.834]                     }
[17:29:48.834]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.834]                   }
[17:29:48.834]                 }
[17:29:48.834]             }
[17:29:48.834]         }))
[17:29:48.834]     }, error = function(ex) {
[17:29:48.834]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:48.834]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.834]                 ...future.rng), started = ...future.startTime, 
[17:29:48.834]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:48.834]             version = "1.8"), class = "FutureResult")
[17:29:48.834]     }, finally = {
[17:29:48.834]         if (!identical(...future.workdir, getwd())) 
[17:29:48.834]             setwd(...future.workdir)
[17:29:48.834]         {
[17:29:48.834]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:48.834]                 ...future.oldOptions$nwarnings <- NULL
[17:29:48.834]             }
[17:29:48.834]             base::options(...future.oldOptions)
[17:29:48.834]             if (.Platform$OS.type == "windows") {
[17:29:48.834]                 old_names <- names(...future.oldEnvVars)
[17:29:48.834]                 envs <- base::Sys.getenv()
[17:29:48.834]                 names <- names(envs)
[17:29:48.834]                 common <- intersect(names, old_names)
[17:29:48.834]                 added <- setdiff(names, old_names)
[17:29:48.834]                 removed <- setdiff(old_names, names)
[17:29:48.834]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:48.834]                   envs[common]]
[17:29:48.834]                 NAMES <- toupper(changed)
[17:29:48.834]                 args <- list()
[17:29:48.834]                 for (kk in seq_along(NAMES)) {
[17:29:48.834]                   name <- changed[[kk]]
[17:29:48.834]                   NAME <- NAMES[[kk]]
[17:29:48.834]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.834]                     next
[17:29:48.834]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.834]                 }
[17:29:48.834]                 NAMES <- toupper(added)
[17:29:48.834]                 for (kk in seq_along(NAMES)) {
[17:29:48.834]                   name <- added[[kk]]
[17:29:48.834]                   NAME <- NAMES[[kk]]
[17:29:48.834]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.834]                     next
[17:29:48.834]                   args[[name]] <- ""
[17:29:48.834]                 }
[17:29:48.834]                 NAMES <- toupper(removed)
[17:29:48.834]                 for (kk in seq_along(NAMES)) {
[17:29:48.834]                   name <- removed[[kk]]
[17:29:48.834]                   NAME <- NAMES[[kk]]
[17:29:48.834]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.834]                     next
[17:29:48.834]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.834]                 }
[17:29:48.834]                 if (length(args) > 0) 
[17:29:48.834]                   base::do.call(base::Sys.setenv, args = args)
[17:29:48.834]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:48.834]             }
[17:29:48.834]             else {
[17:29:48.834]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:48.834]             }
[17:29:48.834]             {
[17:29:48.834]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:48.834]                   0L) {
[17:29:48.834]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:48.834]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:48.834]                   base::options(opts)
[17:29:48.834]                 }
[17:29:48.834]                 {
[17:29:48.834]                   {
[17:29:48.834]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:48.834]                     NULL
[17:29:48.834]                   }
[17:29:48.834]                   options(future.plan = NULL)
[17:29:48.834]                   if (is.na(NA_character_)) 
[17:29:48.834]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.834]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:48.834]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:48.834]                     .init = FALSE)
[17:29:48.834]                 }
[17:29:48.834]             }
[17:29:48.834]         }
[17:29:48.834]     })
[17:29:48.834]     if (TRUE) {
[17:29:48.834]         base::sink(type = "output", split = FALSE)
[17:29:48.834]         if (TRUE) {
[17:29:48.834]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:48.834]         }
[17:29:48.834]         else {
[17:29:48.834]             ...future.result["stdout"] <- base::list(NULL)
[17:29:48.834]         }
[17:29:48.834]         base::close(...future.stdout)
[17:29:48.834]         ...future.stdout <- NULL
[17:29:48.834]     }
[17:29:48.834]     ...future.result$conditions <- ...future.conditions
[17:29:48.834]     ...future.result$finished <- base::Sys.time()
[17:29:48.834]     ...future.result
[17:29:48.834] }
[17:29:48.842] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:48.863] receiveMessageFromWorker() for ClusterFuture ...
[17:29:48.864] - Validating connection of MultisessionFuture
[17:29:48.864] - received message: FutureResult
[17:29:48.865] - Received FutureResult
[17:29:48.865] - Erased future from FutureRegistry
[17:29:48.865] result() for ClusterFuture ...
[17:29:48.866] - result already collected: FutureResult
[17:29:48.866] result() for ClusterFuture ... done
[17:29:48.866] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:48.867] result() for ClusterFuture ...
[17:29:48.867] - result already collected: FutureResult
[17:29:48.867] result() for ClusterFuture ... done
[17:29:48.867] result() for ClusterFuture ...
[17:29:48.868] - result already collected: FutureResult
[17:29:48.868] result() for ClusterFuture ... done
[17:29:48.869] Exporting 1 global objects (436 bytes) to cluster node #1 ...
[17:29:48.870] Exporting 'x' (133 bytes) to cluster node #1 ...
[17:29:48.871] Exporting 'x' (133 bytes) to cluster node #1 ... DONE
[17:29:48.871] Exporting 1 global objects (436 bytes) to cluster node #1 ... DONE
[17:29:48.872] MultisessionFuture started
[17:29:48.872] - Launch lazy future ... done
[17:29:48.873] run() for 'MultisessionFuture' ... done
[17:29:48.874] getGlobalsAndPackages() ...
[17:29:48.874] Searching for globals...
[17:29:48.876] - globals found: [3] '{', 'sample', 'x'
[17:29:48.877] Searching for globals ... DONE
[17:29:48.877] Resolving globals: FALSE
[17:29:48.878] The total size of the 1 globals is 133 bytes (133 bytes)
[17:29:48.879] The total size of the 1 globals exported for future expression ('{; sample(x, size = 1L); }') is 133 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (133 bytes of class 'numeric')
[17:29:48.879] - globals: [1] 'x'
[17:29:48.879] 
[17:29:48.880] getGlobalsAndPackages() ... DONE
[17:29:48.880] run() for 'Future' ...
[17:29:48.881] - state: 'created'
[17:29:48.881] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:29:48.901] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:29:48.901] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:29:48.902]   - Field: 'node'
[17:29:48.902]   - Field: 'label'
[17:29:48.902]   - Field: 'local'
[17:29:48.903]   - Field: 'owner'
[17:29:48.903]   - Field: 'envir'
[17:29:48.903]   - Field: 'workers'
[17:29:48.904]   - Field: 'packages'
[17:29:48.904]   - Field: 'gc'
[17:29:48.904]   - Field: 'conditions'
[17:29:48.905]   - Field: 'persistent'
[17:29:48.905]   - Field: 'expr'
[17:29:48.905]   - Field: 'uuid'
[17:29:48.906]   - Field: 'seed'
[17:29:48.906]   - Field: 'version'
[17:29:48.906]   - Field: 'result'
[17:29:48.907]   - Field: 'asynchronous'
[17:29:48.907]   - Field: 'calls'
[17:29:48.907]   - Field: 'globals'
[17:29:48.908]   - Field: 'stdout'
[17:29:48.908]   - Field: 'earlySignal'
[17:29:48.908]   - Field: 'lazy'
[17:29:48.909]   - Field: 'state'
[17:29:48.909] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:29:48.909] - Launch lazy future ...
[17:29:48.910] Packages needed by the future expression (n = 0): <none>
[17:29:48.910] Packages needed by future strategies (n = 0): <none>
[17:29:48.911] {
[17:29:48.911]     {
[17:29:48.911]         {
[17:29:48.911]             ...future.startTime <- base::Sys.time()
[17:29:48.911]             {
[17:29:48.911]                 {
[17:29:48.911]                   {
[17:29:48.911]                     {
[17:29:48.911]                       base::local({
[17:29:48.911]                         has_future <- base::requireNamespace("future", 
[17:29:48.911]                           quietly = TRUE)
[17:29:48.911]                         if (has_future) {
[17:29:48.911]                           ns <- base::getNamespace("future")
[17:29:48.911]                           version <- ns[[".package"]][["version"]]
[17:29:48.911]                           if (is.null(version)) 
[17:29:48.911]                             version <- utils::packageVersion("future")
[17:29:48.911]                         }
[17:29:48.911]                         else {
[17:29:48.911]                           version <- NULL
[17:29:48.911]                         }
[17:29:48.911]                         if (!has_future || version < "1.8.0") {
[17:29:48.911]                           info <- base::c(r_version = base::gsub("R version ", 
[17:29:48.911]                             "", base::R.version$version.string), 
[17:29:48.911]                             platform = base::sprintf("%s (%s-bit)", 
[17:29:48.911]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:29:48.911]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:29:48.911]                               "release", "version")], collapse = " "), 
[17:29:48.911]                             hostname = base::Sys.info()[["nodename"]])
[17:29:48.911]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:29:48.911]                             info)
[17:29:48.911]                           info <- base::paste(info, collapse = "; ")
[17:29:48.911]                           if (!has_future) {
[17:29:48.911]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:29:48.911]                               info)
[17:29:48.911]                           }
[17:29:48.911]                           else {
[17:29:48.911]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:29:48.911]                               info, version)
[17:29:48.911]                           }
[17:29:48.911]                           base::stop(msg)
[17:29:48.911]                         }
[17:29:48.911]                       })
[17:29:48.911]                     }
[17:29:48.911]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:29:48.911]                     base::options(mc.cores = 1L)
[17:29:48.911]                   }
[17:29:48.911]                   ...future.strategy.old <- future::plan("list")
[17:29:48.911]                   options(future.plan = NULL)
[17:29:48.911]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.911]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:29:48.911]                 }
[17:29:48.911]                 ...future.workdir <- getwd()
[17:29:48.911]             }
[17:29:48.911]             ...future.oldOptions <- base::as.list(base::.Options)
[17:29:48.911]             ...future.oldEnvVars <- base::Sys.getenv()
[17:29:48.911]         }
[17:29:48.911]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[17:29:48.911]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:29:48.911]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[17:29:48.911]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[17:29:48.911]             future.rng.onMisuse = "error", future.rng.onMisuse.keepFuture = NULL, 
[17:29:48.911]             future.stdout.windows.reencode = NULL, width = 80L)
[17:29:48.911]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:29:48.911]             base::names(...future.oldOptions))
[17:29:48.911]     }
[17:29:48.911]     if (FALSE) {
[17:29:48.911]     }
[17:29:48.911]     else {
[17:29:48.911]         if (TRUE) {
[17:29:48.911]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:29:48.911]                 open = "w")
[17:29:48.911]         }
[17:29:48.911]         else {
[17:29:48.911]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:29:48.911]                 windows = "NUL", "/dev/null"), open = "w")
[17:29:48.911]         }
[17:29:48.911]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:29:48.911]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:29:48.911]             base::sink(type = "output", split = FALSE)
[17:29:48.911]             base::close(...future.stdout)
[17:29:48.911]         }, add = TRUE)
[17:29:48.911]     }
[17:29:48.911]     ...future.frame <- base::sys.nframe()
[17:29:48.911]     ...future.conditions <- base::list()
[17:29:48.911]     ...future.rng <- base::globalenv()$.Random.seed
[17:29:48.911]     if (FALSE) {
[17:29:48.911]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:29:48.911]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:29:48.911]     }
[17:29:48.911]     ...future.result <- base::tryCatch({
[17:29:48.911]         base::withCallingHandlers({
[17:29:48.911]             ...future.value <- base::withVisible(base::local({
[17:29:48.911]                 ...future.makeSendCondition <- base::local({
[17:29:48.911]                   sendCondition <- NULL
[17:29:48.911]                   function(frame = 1L) {
[17:29:48.911]                     if (is.function(sendCondition)) 
[17:29:48.911]                       return(sendCondition)
[17:29:48.911]                     ns <- getNamespace("parallel")
[17:29:48.911]                     if (exists("sendData", mode = "function", 
[17:29:48.911]                       envir = ns)) {
[17:29:48.911]                       parallel_sendData <- get("sendData", mode = "function", 
[17:29:48.911]                         envir = ns)
[17:29:48.911]                       envir <- sys.frame(frame)
[17:29:48.911]                       master <- NULL
[17:29:48.911]                       while (!identical(envir, .GlobalEnv) && 
[17:29:48.911]                         !identical(envir, emptyenv())) {
[17:29:48.911]                         if (exists("master", mode = "list", envir = envir, 
[17:29:48.911]                           inherits = FALSE)) {
[17:29:48.911]                           master <- get("master", mode = "list", 
[17:29:48.911]                             envir = envir, inherits = FALSE)
[17:29:48.911]                           if (inherits(master, c("SOCKnode", 
[17:29:48.911]                             "SOCK0node"))) {
[17:29:48.911]                             sendCondition <<- function(cond) {
[17:29:48.911]                               data <- list(type = "VALUE", value = cond, 
[17:29:48.911]                                 success = TRUE)
[17:29:48.911]                               parallel_sendData(master, data)
[17:29:48.911]                             }
[17:29:48.911]                             return(sendCondition)
[17:29:48.911]                           }
[17:29:48.911]                         }
[17:29:48.911]                         frame <- frame + 1L
[17:29:48.911]                         envir <- sys.frame(frame)
[17:29:48.911]                       }
[17:29:48.911]                     }
[17:29:48.911]                     sendCondition <<- function(cond) NULL
[17:29:48.911]                   }
[17:29:48.911]                 })
[17:29:48.911]                 withCallingHandlers({
[17:29:48.911]                   {
[17:29:48.911]                     sample(x, size = 1L)
[17:29:48.911]                   }
[17:29:48.911]                 }, immediateCondition = function(cond) {
[17:29:48.911]                   sendCondition <- ...future.makeSendCondition()
[17:29:48.911]                   sendCondition(cond)
[17:29:48.911]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.911]                   {
[17:29:48.911]                     inherits <- base::inherits
[17:29:48.911]                     invokeRestart <- base::invokeRestart
[17:29:48.911]                     is.null <- base::is.null
[17:29:48.911]                     muffled <- FALSE
[17:29:48.911]                     if (inherits(cond, "message")) {
[17:29:48.911]                       muffled <- grepl(pattern, "muffleMessage")
[17:29:48.911]                       if (muffled) 
[17:29:48.911]                         invokeRestart("muffleMessage")
[17:29:48.911]                     }
[17:29:48.911]                     else if (inherits(cond, "warning")) {
[17:29:48.911]                       muffled <- grepl(pattern, "muffleWarning")
[17:29:48.911]                       if (muffled) 
[17:29:48.911]                         invokeRestart("muffleWarning")
[17:29:48.911]                     }
[17:29:48.911]                     else if (inherits(cond, "condition")) {
[17:29:48.911]                       if (!is.null(pattern)) {
[17:29:48.911]                         computeRestarts <- base::computeRestarts
[17:29:48.911]                         grepl <- base::grepl
[17:29:48.911]                         restarts <- computeRestarts(cond)
[17:29:48.911]                         for (restart in restarts) {
[17:29:48.911]                           name <- restart$name
[17:29:48.911]                           if (is.null(name)) 
[17:29:48.911]                             next
[17:29:48.911]                           if (!grepl(pattern, name)) 
[17:29:48.911]                             next
[17:29:48.911]                           invokeRestart(restart)
[17:29:48.911]                           muffled <- TRUE
[17:29:48.911]                           break
[17:29:48.911]                         }
[17:29:48.911]                       }
[17:29:48.911]                     }
[17:29:48.911]                     invisible(muffled)
[17:29:48.911]                   }
[17:29:48.911]                   muffleCondition(cond)
[17:29:48.911]                 })
[17:29:48.911]             }))
[17:29:48.911]             future::FutureResult(value = ...future.value$value, 
[17:29:48.911]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.911]                   ...future.rng), globalenv = if (FALSE) 
[17:29:48.911]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:29:48.911]                     ...future.globalenv.names))
[17:29:48.911]                 else NULL, started = ...future.startTime, version = "1.8")
[17:29:48.911]         }, condition = base::local({
[17:29:48.911]             c <- base::c
[17:29:48.911]             inherits <- base::inherits
[17:29:48.911]             invokeRestart <- base::invokeRestart
[17:29:48.911]             length <- base::length
[17:29:48.911]             list <- base::list
[17:29:48.911]             seq.int <- base::seq.int
[17:29:48.911]             signalCondition <- base::signalCondition
[17:29:48.911]             sys.calls <- base::sys.calls
[17:29:48.911]             `[[` <- base::`[[`
[17:29:48.911]             `+` <- base::`+`
[17:29:48.911]             `<<-` <- base::`<<-`
[17:29:48.911]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:29:48.911]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:29:48.911]                   3L)]
[17:29:48.911]             }
[17:29:48.911]             function(cond) {
[17:29:48.911]                 is_error <- inherits(cond, "error")
[17:29:48.911]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:29:48.911]                   NULL)
[17:29:48.911]                 if (is_error) {
[17:29:48.911]                   sessionInformation <- function() {
[17:29:48.911]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:29:48.911]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:29:48.911]                       search = base::search(), system = base::Sys.info())
[17:29:48.911]                   }
[17:29:48.911]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.911]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:29:48.911]                     cond$call), session = sessionInformation(), 
[17:29:48.911]                     timestamp = base::Sys.time(), signaled = 0L)
[17:29:48.911]                   signalCondition(cond)
[17:29:48.911]                 }
[17:29:48.911]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:29:48.911]                 "immediateCondition"))) {
[17:29:48.911]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:29:48.911]                   ...future.conditions[[length(...future.conditions) + 
[17:29:48.911]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:29:48.911]                   if (TRUE && !signal) {
[17:29:48.911]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.911]                     {
[17:29:48.911]                       inherits <- base::inherits
[17:29:48.911]                       invokeRestart <- base::invokeRestart
[17:29:48.911]                       is.null <- base::is.null
[17:29:48.911]                       muffled <- FALSE
[17:29:48.911]                       if (inherits(cond, "message")) {
[17:29:48.911]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.911]                         if (muffled) 
[17:29:48.911]                           invokeRestart("muffleMessage")
[17:29:48.911]                       }
[17:29:48.911]                       else if (inherits(cond, "warning")) {
[17:29:48.911]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.911]                         if (muffled) 
[17:29:48.911]                           invokeRestart("muffleWarning")
[17:29:48.911]                       }
[17:29:48.911]                       else if (inherits(cond, "condition")) {
[17:29:48.911]                         if (!is.null(pattern)) {
[17:29:48.911]                           computeRestarts <- base::computeRestarts
[17:29:48.911]                           grepl <- base::grepl
[17:29:48.911]                           restarts <- computeRestarts(cond)
[17:29:48.911]                           for (restart in restarts) {
[17:29:48.911]                             name <- restart$name
[17:29:48.911]                             if (is.null(name)) 
[17:29:48.911]                               next
[17:29:48.911]                             if (!grepl(pattern, name)) 
[17:29:48.911]                               next
[17:29:48.911]                             invokeRestart(restart)
[17:29:48.911]                             muffled <- TRUE
[17:29:48.911]                             break
[17:29:48.911]                           }
[17:29:48.911]                         }
[17:29:48.911]                       }
[17:29:48.911]                       invisible(muffled)
[17:29:48.911]                     }
[17:29:48.911]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.911]                   }
[17:29:48.911]                 }
[17:29:48.911]                 else {
[17:29:48.911]                   if (TRUE) {
[17:29:48.911]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:29:48.911]                     {
[17:29:48.911]                       inherits <- base::inherits
[17:29:48.911]                       invokeRestart <- base::invokeRestart
[17:29:48.911]                       is.null <- base::is.null
[17:29:48.911]                       muffled <- FALSE
[17:29:48.911]                       if (inherits(cond, "message")) {
[17:29:48.911]                         muffled <- grepl(pattern, "muffleMessage")
[17:29:48.911]                         if (muffled) 
[17:29:48.911]                           invokeRestart("muffleMessage")
[17:29:48.911]                       }
[17:29:48.911]                       else if (inherits(cond, "warning")) {
[17:29:48.911]                         muffled <- grepl(pattern, "muffleWarning")
[17:29:48.911]                         if (muffled) 
[17:29:48.911]                           invokeRestart("muffleWarning")
[17:29:48.911]                       }
[17:29:48.911]                       else if (inherits(cond, "condition")) {
[17:29:48.911]                         if (!is.null(pattern)) {
[17:29:48.911]                           computeRestarts <- base::computeRestarts
[17:29:48.911]                           grepl <- base::grepl
[17:29:48.911]                           restarts <- computeRestarts(cond)
[17:29:48.911]                           for (restart in restarts) {
[17:29:48.911]                             name <- restart$name
[17:29:48.911]                             if (is.null(name)) 
[17:29:48.911]                               next
[17:29:48.911]                             if (!grepl(pattern, name)) 
[17:29:48.911]                               next
[17:29:48.911]                             invokeRestart(restart)
[17:29:48.911]                             muffled <- TRUE
[17:29:48.911]                             break
[17:29:48.911]                           }
[17:29:48.911]                         }
[17:29:48.911]                       }
[17:29:48.911]                       invisible(muffled)
[17:29:48.911]                     }
[17:29:48.911]                     muffleCondition(cond, pattern = "^muffle")
[17:29:48.911]                   }
[17:29:48.911]                 }
[17:29:48.911]             }
[17:29:48.911]         }))
[17:29:48.911]     }, error = function(ex) {
[17:29:48.911]         base::structure(base::list(value = NULL, visible = NULL, 
[17:29:48.911]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:29:48.911]                 ...future.rng), started = ...future.startTime, 
[17:29:48.911]             finished = Sys.time(), session_uuid = NA_character_, 
[17:29:48.911]             version = "1.8"), class = "FutureResult")
[17:29:48.911]     }, finally = {
[17:29:48.911]         if (!identical(...future.workdir, getwd())) 
[17:29:48.911]             setwd(...future.workdir)
[17:29:48.911]         {
[17:29:48.911]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:29:48.911]                 ...future.oldOptions$nwarnings <- NULL
[17:29:48.911]             }
[17:29:48.911]             base::options(...future.oldOptions)
[17:29:48.911]             if (.Platform$OS.type == "windows") {
[17:29:48.911]                 old_names <- names(...future.oldEnvVars)
[17:29:48.911]                 envs <- base::Sys.getenv()
[17:29:48.911]                 names <- names(envs)
[17:29:48.911]                 common <- intersect(names, old_names)
[17:29:48.911]                 added <- setdiff(names, old_names)
[17:29:48.911]                 removed <- setdiff(old_names, names)
[17:29:48.911]                 changed <- common[...future.oldEnvVars[common] != 
[17:29:48.911]                   envs[common]]
[17:29:48.911]                 NAMES <- toupper(changed)
[17:29:48.911]                 args <- list()
[17:29:48.911]                 for (kk in seq_along(NAMES)) {
[17:29:48.911]                   name <- changed[[kk]]
[17:29:48.911]                   NAME <- NAMES[[kk]]
[17:29:48.911]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.911]                     next
[17:29:48.911]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.911]                 }
[17:29:48.911]                 NAMES <- toupper(added)
[17:29:48.911]                 for (kk in seq_along(NAMES)) {
[17:29:48.911]                   name <- added[[kk]]
[17:29:48.911]                   NAME <- NAMES[[kk]]
[17:29:48.911]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.911]                     next
[17:29:48.911]                   args[[name]] <- ""
[17:29:48.911]                 }
[17:29:48.911]                 NAMES <- toupper(removed)
[17:29:48.911]                 for (kk in seq_along(NAMES)) {
[17:29:48.911]                   name <- removed[[kk]]
[17:29:48.911]                   NAME <- NAMES[[kk]]
[17:29:48.911]                   if (name != NAME && is.element(NAME, old_names)) 
[17:29:48.911]                     next
[17:29:48.911]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:29:48.911]                 }
[17:29:48.911]                 if (length(args) > 0) 
[17:29:48.911]                   base::do.call(base::Sys.setenv, args = args)
[17:29:48.911]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:29:48.911]             }
[17:29:48.911]             else {
[17:29:48.911]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:29:48.911]             }
[17:29:48.911]             {
[17:29:48.911]                 if (base::length(...future.futureOptionsAdded) > 
[17:29:48.911]                   0L) {
[17:29:48.911]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:29:48.911]                   base::names(opts) <- ...future.futureOptionsAdded
[17:29:48.911]                   base::options(opts)
[17:29:48.911]                 }
[17:29:48.911]                 {
[17:29:48.911]                   {
[17:29:48.911]                     base::options(mc.cores = ...future.mc.cores.old)
[17:29:48.911]                     NULL
[17:29:48.911]                   }
[17:29:48.911]                   options(future.plan = NULL)
[17:29:48.911]                   if (is.na(NA_character_)) 
[17:29:48.911]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:29:48.911]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:29:48.911]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:29:48.911]                     .init = FALSE)
[17:29:48.911]                 }
[17:29:48.911]             }
[17:29:48.911]         }
[17:29:48.911]     })
[17:29:48.911]     if (TRUE) {
[17:29:48.911]         base::sink(type = "output", split = FALSE)
[17:29:48.911]         if (TRUE) {
[17:29:48.911]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:29:48.911]         }
[17:29:48.911]         else {
[17:29:48.911]             ...future.result["stdout"] <- base::list(NULL)
[17:29:48.911]         }
[17:29:48.911]         base::close(...future.stdout)
[17:29:48.911]         ...future.stdout <- NULL
[17:29:48.911]     }
[17:29:48.911]     ...future.result$conditions <- ...future.conditions
[17:29:48.911]     ...future.result$finished <- base::Sys.time()
[17:29:48.911]     ...future.result
[17:29:48.911] }
[17:29:48.919] Poll #1 (0): usedNodes() = 2, workers = 2
[17:29:48.942] receiveMessageFromWorker() for ClusterFuture ...
[17:29:48.942] - Validating connection of MultisessionFuture
[17:29:48.943] - received message: FutureResult
[17:29:48.943] - Received FutureResult
[17:29:48.943] - Erased future from FutureRegistry
[17:29:48.944] result() for ClusterFuture ...
[17:29:48.944] - result already collected: FutureResult
[17:29:48.944] result() for ClusterFuture ... done
[17:29:48.944] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:48.945] result() for ClusterFuture ...
[17:29:48.945] - result already collected: FutureResult
[17:29:48.945] result() for ClusterFuture ... done
[17:29:48.945] result() for ClusterFuture ...
[17:29:48.946] - result already collected: FutureResult
[17:29:48.946] result() for ClusterFuture ... done
[17:29:48.947] Exporting 1 global objects (436 bytes) to cluster node #2 ...
[17:29:48.948] Exporting 'x' (133 bytes) to cluster node #2 ...
[17:29:48.948] Exporting 'x' (133 bytes) to cluster node #2 ... DONE
[17:29:48.949] Exporting 1 global objects (436 bytes) to cluster node #2 ... DONE
[17:29:48.950] MultisessionFuture started
[17:29:48.950] - Launch lazy future ... done
[17:29:48.950] run() for 'MultisessionFuture' ... done
[17:29:48.951] result() for ClusterFuture ...
[17:29:48.951] - result already collected: FutureResult
[17:29:48.951] result() for ClusterFuture ... done
[17:29:48.951] result() for ClusterFuture ...
[17:29:48.952] - result already collected: FutureResult
[17:29:48.952] result() for ClusterFuture ... done
[17:29:48.952] result() for ClusterFuture ...
[17:29:48.953] - result already collected: FutureResult
[17:29:48.953] result() for ClusterFuture ... done
[17:29:48.953] result() for ClusterFuture ...
[17:29:48.953] - result already collected: FutureResult
[17:29:48.954] result() for ClusterFuture ... done
[17:29:48.954] result() for ClusterFuture ...
[17:29:48.954] receiveMessageFromWorker() for ClusterFuture ...
[17:29:48.954] - Validating connection of MultisessionFuture
[17:29:48.955] - received message: FutureResult
[17:29:48.955] - Received FutureResult
[17:29:48.955] - Erased future from FutureRegistry
[17:29:48.956] result() for ClusterFuture ...
[17:29:48.956] - result already collected: FutureResult
[17:29:48.956] result() for ClusterFuture ... done
[17:29:48.956] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:48.957] result() for ClusterFuture ... done
[17:29:48.957] result() for ClusterFuture ...
[17:29:48.957] - result already collected: FutureResult
[17:29:48.957] result() for ClusterFuture ... done
[17:29:48.958] result() for ClusterFuture ...
[17:29:48.958] receiveMessageFromWorker() for ClusterFuture ...
[17:29:48.958] - Validating connection of MultisessionFuture
[17:29:48.973] - received message: FutureResult
[17:29:48.974] - Received FutureResult
[17:29:48.974] - Erased future from FutureRegistry
[17:29:48.974] result() for ClusterFuture ...
[17:29:48.975] - result already collected: FutureResult
[17:29:48.975] result() for ClusterFuture ... done
[17:29:48.975] receiveMessageFromWorker() for ClusterFuture ... done
[17:29:48.976] result() for ClusterFuture ... done
[17:29:48.976] result() for ClusterFuture ...
[17:29:48.976] - result already collected: FutureResult
[17:29:48.976] result() for ClusterFuture ... done
[[1]]
[1] 3

[[2]]
[1] 2

[[3]]
[1] 3

[[4]]
[1] 3

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.02946901 secs (started 2024-07-29 17:29:49.015099)
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.03107715 secs (started 2024-07-29 17:29:49.085085)
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=205] '!ExitCode', 'ALLUSERSPROFILE', 'APPDATA', 'BIBINPUTS', 'BINDIR', 'BSTINPUTS', 'COMMONPROGRAMFILES', 'COMPUTERNAME', 'COMSPEC', 'CURL_CA_BUNDLE', 'CYGWIN', 'CommonProgramFiles(x86)', 'CommonProgramW6432', 'DriverData', 'HOME', 'HOMEDRIVE', 'HOMEPATH', 'JAGS_ROOT', 'JAVA_HOME', 'LANGUAGE', 'LC_COLLATE', 'LC_MONETARY', 'LC_TIME', 'LOCALAPPDATA', 'LOGONSERVER', 'LS_HOME', 'LS_LICENSE_PATH', 'MAKE', 'MAKEFLAGS', 'MAKELEVEL', 'MFLAGS', 'MSMPI_BENCHMARKS', 'MSMPI_BIN', 'MSYS2_ENV_CONV_EXCL', 'NUMBER_OF_PROCESSORS', 'OCL', 'OMP_THREAD_LIMIT', 'OS', 'PATH', 'PATHEXT', 'PROCESSOR_ARCHITECTURE', 'PROCESSOR_IDENTIFIER', 'PROCESSOR_LEVEL', 'PROCESSOR_REVISION', 'PROGRAMFILES', 'PROMPT', 'PSModulePath', 'PUBLIC', 'PWD', 'ProgramData', 'ProgramFiles(x86)', 'ProgramW6432', 'RTOOLS43_HOME', 'RTOOLS44_HOME', 'R_ARCH', 'R_BROWSER', 'R_BZIPCMD', 'R_CMD', 'R_COMPILED_BY', 'R_CRAN_WEB', 'R_CUSTOM_TOOLS_PATH', 'R_CUSTOM_TOOLS_SOFT', 'R_DOC_DIR', 'R_ENVIRON_USER', 'R_GSCMD', 'R_GZIPCMD', 'R_HOME', 'R_INCLUDE_DIR', 'R_INSTALL_TAR', 'R_LIBS', 'R_LIBS_SITE', 'R_LIBS_USER', 'R_MAX_NUM_DLLS', 'R_OSTYPE', 'R_PAPERSIZE', 'R_PAPERSIZE_USER', 'R_PARALLELLY_MAKENODEPSOCK_AUTOKILL', 'R_PARALLELLY_MAKENODEPSOCK_CONNECTTIMEOUT', 'R_PARALLELLY_MAKENODEPSOCK_RSCRIPT_LABEL', 'R_PARALLELLY_MAKENODEPSOCK_SESSIONINFO_PKGS', 'R_PARALLELLY_MAKENODEPSOCK_TIMEOUT', 'R_PARALLELLY_RANDOM_PORTS', 'R_PARALLEL_PORT', 'R_RD4PDF', 'R_RTOOLS44_PATH', 'R_SCRIPT_LEGACY', 'R_SHARE_DIR', 'R_TESTS', 'R_UNZIPCMD', 'R_USER', 'R_VERSION', 'R_ZIPCMD', 'SED', 'SHLVL', 'SYSTEMDRIVE', 'SYSTEMROOT', 'TAR', 'TAR_OPTIONS', 'TEMP', 'TERM', 'TEXINPUTS', 'TMP', 'TMPDIR', 'USERDOMAIN', 'USERDOMAIN_ROAMINGPROFILE', 'USERNAME', 'USERPROFILE', 'WINDIR', '_', '_R_CHECK_AUTOCONF_', '_R_CHECK_BOGUS_RETURN_', '_R_CHECK_BROWSER_NONINTERACTIVE_', '_R_CHECK_BUILD_VIGNETTES_SEPARATELY_', '_R_CHECK_CODETOOLS_PROFILE_', '_R_CHECK_CODE_ASSIGN_TO_GLOBALENV_', '_R_CHECK_CODE_ATTACH_', '_R_CHECK_CODE_CLASS_IS_STRING_', '_R_CHECK_CODE_DATA_INTO_GLOBALENV_', '_R_CHECK_CODE_USAGE_VIA_NAMESPACES_', '_R_CHECK_CODE_USAGE_WITHOUT_LOADING_', '_R_CHECK_CODE_USAGE_WITH_ONLY_BASE_ATTACHED_', '_R_CHECK_CODOC_VARIABLES_IN_USAGES_', '_R_CHECK_COMPACT_DATA2_', '_R_CHECK_COMPILATION_FLAGS_', '_R_CHECK_CONNECTIONS_LEFT_OPEN_', '_R_CHECK_CRAN_INCOMING_', '_R_CHECK_CRAN_INCOMING_CHECK_FILE_URIS_', '_R_CHECK_CRAN_INCOMING_CHECK_URLS_IN_PARALLEL_', '_R_CHECK_CRAN_INCOMING_NOTE_GNU_MAKE_', '_R_CHECK_CRAN_INCOMING_REMOTE_', '_R_CHECK_CRAN_INCOMING_USE_ASPELL_', '_R_CHECK_DATALIST_', '_R_CHECK_DEPRECATED_DEFUNCT_', '_R_CHECK_DOC_SIZES2_', '_R_CHECK_DOT_FIRSTLIB_', '_R_CHECK_DOT_INTERNAL_', '_R_CHECK_EXAMPLE_TIMING_THRESHOLD_', '_R_CHECK_EXECUTABLES_', '_R_CHECK_EXECUTABLES_EXCLUSIONS_', '_R_CHECK_FF_CALLS_', '_R_CHECK_FF_DUP_', '_R_CHECK_FORCE_SUGGESTS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_LEEWAY_', '_R_CHECK_HAVE_MYSQL_', '_R_CHECK_HAVE_ODBC_', '_R_CHECK_HAVE_PERL_', '_R_CHECK_HAVE_POSTGRES_', '_R_CHECK_INSTALL_DEPENDS_', '_R_CHECK_INTERNALS2_', '_R_CHECK_LENGTH_1_CONDITION_', '_R_CHECK_LICENSE_', '_R_CHECK_LIMIT_CORES_', '_R_CHECK_MATRIX_DATA_', '_R_CHECK_MBCS_CONVERSION_FAILURE_', '_R_CHECK_NATIVE_ROUTINE_REGISTRATION_', '_R_CHECK_NEWS_IN_PLAIN_TEXT_', '_R_CHECK_NO_RECOMMENDED_', '_R_CHECK_NO_STOP_ON_TEST_ERROR_', '_R_CHECK_ORPHANED_', '_R_CHECK_OVERWRITE_REGISTERED_S3_METHODS_', '_R_CHECK_PACKAGES_USED_IGNORE_UNUSED_IMPORTS_', '_R_CHECK_PACKAGES_USED_IN_TESTS_USE_SUBDIRS_', '_R_CHECK_PACKAGE_DATASETS_SUPPRESS_NOTES_', '_R_CHECK_PACKAGE_NAME_', '_R_CHECK_PKG_SIZES_', '_R_CHECK_PKG_SIZES_THRESHOLD_', '_R_CHECK_PRAGMAS_', '_R_CHECK_RD_EXAMPLES_T_AND_F_', '_R_CHECK_RD_LINE_WIDTHS_', '_R_CHECK_RD_MATH_RENDERING_', '_R_CHECK_RD_NOTE_LOST_BRACES_', '_R_CHECK_RD_VALIDATE_RD2HTML_', '_R_CHECK_REPLACING_IMPORTS_', '_R_CHECK_R_DEPENDS_', '_R_CHECK_S3_METHODS_SHOW_POSSIBLE_ISSUES_', '_R_CHECK_SCREEN_DEVICE_', '_R_CHECK_SERIALIZATION_', '_R_CHECK_SHLIB_OPENMP_FLAGS_', '_R_CHECK_SRC_MINUS_W_IMPLICIT_', '_R_CHECK_SUBDIRS_NOCASE_', '_R_CHECK_SUGGESTS_ONLY_', '_R_CHECK_SYSTEM_CLOCK_', '_R_CHECK_TESTS_NLINES_', '_R_CHECK_TEST_TIMING_', '_R_CHECK_TIMINGS_', '_R_CHECK_TOPLEVEL_FILES_', '_R_CHECK_UNDOC_USE_ALL_NAMES_', '_R_CHECK_UNSAFE_CALLS_', '_R_CHECK_URLS_SHOW_301_STATUS_', '_R_CHECK_VC_DIRS_', '_R_CHECK_VIGNETTES_NLINES_', '_R_CHECK_VIGNETTES_SKIP_RUN_MAYBE_', '_R_CHECK_VIGNETTE_TIMING_', '_R_CHECK_VIGNETTE_TITLES_', '_R_CHECK_WINDOWS_DEVICE_', '_R_CHECK_XREFS_NOTE_MISSING_PACKAGE_ANCHORS_', '_R_CHECK_XREFS_USE_ALIASES_FROM_CRAN_', '_R_CLASS_MATRIX_ARRAY_', '_R_DEPRECATED_IS_R_', '_R_S3_METHOD_LOOKUP_BASEENV_AFTER_GLOBALENV_', '_R_SHLIB_BUILD_OBJECTS_SYMBOL_TABLES_', '__R_CHECK_DOC_FILES_NOTE_IF_ALL_SPECIAL__', 'maj.version', 'nextArg--timingsnextArg--install'
 - Environment variables still there: [n=0] 
 - Environment variables missing: [n=1] 'MAKEFLAGS'
Differences environment variable by environment variable:
List of 3
 $ name    : chr "MAKEFLAGS"
 $ expected: 'Dlist' chr ""
 $ actual  : 'Dlist' chr NA
> 
> proc.time()
   user  system elapsed 
   6.79    0.32    9.57